@seedtactics/insight-client 16.4.0

package/dist/data/results.cycles.js

@@ -0,0 +1,454 @@
+/* Copyright (c) 2024, 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 { addMinutes, addSeconds } from "date-fns";
+import { durationToMinutes } from "../util/parseISODuration.js";
+import copy from "copy-to-clipboard";
+import { chunkCyclesWithSimilarEndTime, PartAndStationOperation, } from "../cell-status/estimated-cycle-times.js";
+import { stat_name_and_num } from "../cell-status/station-cycles.js";
+import { LazySeq, OrderedSet, OrderedMap } from "@seedtactics/immutable-collections";
+function extractFilterOptions(cycles, selectedPart) {
+    let palNames = OrderedSet.empty();
+    let lulNames = OrderedSet.empty();
+    let mcNames = OrderedSet.empty();
+    let partNames = OrderedMap.empty();
+    let oper = OrderedSet.empty();
+    for (const c of cycles) {
+        palNames = palNames.add(c.pallet);
+        if (c.isLabor) {
+            lulNames = lulNames.add(stat_name_and_num(c.stationGroup, c.stationNumber));
+        }
+        else {
+            mcNames = mcNames.add(stat_name_and_num(c.stationGroup, c.stationNumber));
+            if (selectedPart &&
+                c.part == selectedPart.part &&
+                c.material.some((m) => m.proc === selectedPart.proc)) {
+                oper = oper.add(PartAndStationOperation.ofPartCycle(c));
+            }
+        }
+        for (const m of c.material) {
+            partNames = partNames.alter(m.part, (old) => (old ?? OrderedSet.empty()).add(m.proc));
+        }
+    }
+    return {
+        allPalletNames: palNames.toAscLazySeq().toRArray(),
+        allLoadStationNames: lulNames.toAscLazySeq().toRArray(),
+        allMachineNames: mcNames.toAscLazySeq().toRArray(),
+        allPartAndProcNames: partNames
+            .toAscLazySeq()
+            .flatMap(([part, procs]) => procs.toAscLazySeq().map((proc) => ({ part: part, proc: proc })))
+            .toRArray(),
+        allMachineOperations: oper.toAscLazySeq().toRArray(),
+    };
+}
+export const FilterAnyMachineKey = "@@@_FMSInsight_FilterAnyMachineKey_@@@";
+export const FilterAnyLoadKey = "@@@_FMSInsigt_FilterAnyLoadKey_@@@";
+export function emptyStationCycles(allCycles) {
+    return {
+        ...extractFilterOptions(allCycles),
+        seriesLabel: "Station",
+        data: new Map(),
+    };
+}
+export function filterStationCycles(allCycles, { zoom, partAndProc, pallet, station, operation }) {
+    const groupByPal = partAndProc && station && station !== FilterAnyMachineKey && station !== FilterAnyLoadKey;
+    const groupByPart = pallet && !operation && station && station !== FilterAnyMachineKey && station !== FilterAnyLoadKey;
+    return {
+        ...extractFilterOptions(allCycles, partAndProc),
+        seriesLabel: groupByPal ? "Pallet" : groupByPart ? "Part" : "Station",
+        data: LazySeq.of(allCycles)
+            .filter((e) => {
+            if (zoom && (e.endTime < zoom.start || e.endTime > zoom.end)) {
+                return false;
+            }
+            if (partAndProc &&
+                (e.part !== partAndProc.part || !e.material.some((m) => m.proc === partAndProc.proc))) {
+                return false;
+            }
+            if (pallet && e.pallet !== pallet) {
+                return false;
+            }
+            if (station === FilterAnyMachineKey) {
+                if (e.isLabor) {
+                    return false;
+                }
+            }
+            else if (station === FilterAnyLoadKey) {
+                if (!e.isLabor) {
+                    return false;
+                }
+            }
+            else if (station && stat_name_and_num(e.stationGroup, e.stationNumber) !== station) {
+                return false;
+            }
+            if (operation && operation.compare(PartAndStationOperation.ofPartCycle(e)) !== 0) {
+                return false;
+            }
+            return true;
+        })
+            .toRLookup((e) => {
+            if (groupByPal) {
+                return e.pallet.toString();
+            }
+            else if (groupByPart) {
+                return (e.part +
+                    "-" +
+                    LazySeq.of(e.material)
+                        .map((m) => m.proc)
+                        .distinctAndSortBy((p) => p)
+                        .toRArray()
+                        .join(":"));
+            }
+            else {
+                return stat_name_and_num(e.stationGroup, e.stationNumber);
+            }
+        }, (e) => ({
+            ...e,
+            x: e.endTime,
+            y: e.elapsedMinsPerMaterial * e.material.length,
+        })),
+    };
+}
+export function loadOccupancyCycles(allCycles, { zoom, partAndProc, pallet, station }) {
+    const filteredCycles = LazySeq.of(allCycles).filter((e) => {
+        if (!station || station === FilterAnyLoadKey) {
+            return e.isLabor;
+        }
+        else {
+            return stat_name_and_num(e.stationGroup, e.stationNumber) === station;
+        }
+    });
+    return {
+        ...extractFilterOptions(allCycles, partAndProc),
+        seriesLabel: "Station",
+        data: chunkCyclesWithSimilarEndTime(filteredCycles, (c) => stat_name_and_num(c.stationGroup, c.stationNumber), (c) => c.endTime)
+            .map(([statNameAndNum, cyclesForStat]) => [
+            statNameAndNum,
+            LazySeq.of(cyclesForStat)
+                .collect((chunk) => {
+                const cycle = chunk.find((e) => {
+                    if (zoom && (e.endTime < zoom.start || e.endTime > zoom.end)) {
+                        return false;
+                    }
+                    if (partAndProc &&
+                        (e.part !== partAndProc.part || !e.material.some((m) => m.proc === partAndProc.proc))) {
+                        return false;
+                    }
+                    if (pallet && e.pallet !== pallet) {
+                        return false;
+                    }
+                    return true;
+                });
+                if (cycle) {
+                    return {
+                        ...cycle,
+                        x: cycle.endTime,
+                        y: chunk.reduce((acc, e) => acc + e.elapsedMinsPerMaterial * e.material.length, 0),
+                        operations: LazySeq.of(chunk)
+                            .flatMap((e) => e.material.map((mat) => ({
+                            mat,
+                            operation: e.operation,
+                        })))
+                            .toRArray(),
+                    };
+                }
+                else {
+                    return null;
+                }
+            })
+                .toRArray(),
+        ])
+            .filter(([, e]) => e.length > 0)
+            .toRMap((x) => x),
+    };
+}
+export function plannedOperationMinutes(s, forSingleMat) {
+    let planned = null;
+    for (const [, cycles] of s.data) {
+        for (const pt of cycles) {
+            if (pt.material.length > 0) {
+                if (planned === null || planned.time < pt.x) {
+                    const mins = forSingleMat ? pt.activeMinutes / pt.material.length : pt.activeMinutes;
+                    planned = { time: pt.x, mins };
+                }
+            }
+        }
+    }
+    return planned?.mins;
+}
+export function recentCycles(allCycles) {
+    return chunkCyclesWithSimilarEndTime(allCycles, (c) => stat_name_and_num(c.stationGroup, c.stationNumber), (c) => c.endTime)
+        .flatMap(function* procChunk([station, chunks]) {
+        for (const chunk of chunks) {
+            // sum elapsed time for chunk and subtract from end time to get start time
+            const elapForChunkMins = LazySeq.of(chunk).sumBy((c) => c.elapsedMinsPerMaterial * c.material.length);
+            const startTime = addSeconds(chunk[0].endTime, -elapForChunkMins * 60);
+            const activeMins = LazySeq.of(chunk).sumBy((c) => c.activeMinutes);
+            yield {
+                station,
+                startTime,
+                endActive: activeMins > 0 ? addMinutes(startTime, activeMins) : undefined,
+                endOccupied: chunk[0].endTime,
+                outlier: chunk.some((c) => c.isOutlier),
+                parts: LazySeq.of(chunk)
+                    .flatMap((c) => LazySeq.of(c.material)
+                    .distinctBy((m) => m.proc)
+                    .map((m) => ({ part: c.part, proc: m.proc, oper: c.operation })))
+                    .distinctAndSortBy((c) => c.part, (c) => c.proc, (c) => c.oper)
+                    .map((c) => ({
+                    part: c.part + "-" + c.proc.toString(),
+                    oper: c.oper,
+                }))
+                    .toRArray(),
+            };
+        }
+    })
+        .toRArray();
+}
+// --------------------------------------------------------------------------------
+// Clipboard
+// --------------------------------------------------------------------------------
+export function format_cycle_inspection(c, matsById) {
+    const ret = [];
+    const signaled = new Set();
+    const completed = new Set();
+    const success = new Set();
+    for (const mat of c.material) {
+        const summary = matsById.get(mat.id);
+        if (summary !== undefined) {
+            for (const s of summary.signaledInspections) {
+                signaled.add(s);
+            }
+            for (const [compInsp, details] of LazySeq.ofObject(summary.completedInspections ?? {})) {
+                signaled.add(compInsp);
+                completed.add(compInsp);
+                if (details.success) {
+                    success.add(compInsp);
+                }
+            }
+        }
+    }
+    for (const name of LazySeq.of(signaled).toSortedArray((x) => x)) {
+        if (completed.has(name)) {
+            ret.push(name + "[" + (success.has(name) ? "success" : "failed") + "]");
+        }
+        else {
+            ret.push(name);
+        }
+    }
+    return ret.join(", ");
+}
+export function buildCycleTable(cycles, matsById, startD, endD, hideMedian) {
+    let table = "<table>\n<thead><tr>";
+    table += "<th>Date</th><th>Part</th><th>Station</th><th>Pallet</th>";
+    table += "<th>Serial</th><th>Workorder</th><th>Inspection</th>";
+    table += "<th>Elapsed Min</th><th>Target Min</th>";
+    if (!hideMedian) {
+        table += "<th>Median Elapsed Min</th><th>Median Deviation</th>";
+    }
+    table += "</tr></thead>\n<tbody>\n";
+    const filteredCycles = LazySeq.of(cycles.data)
+        .flatMap(([_, c]) => c)
+        .filter((p) => (!startD || p.endTime >= startD) && (!endD || p.endTime < endD))
+        .toSortedArray((a) => a.endTime.getTime());
+    for (const cycle of filteredCycles) {
+        table += "<tr>";
+        table +=
+            "<td>" +
+                cycle.endTime.toLocaleString(undefined, {
+                    month: "short",
+                    day: "numeric",
+                    year: "numeric",
+                    hour: "numeric",
+                    minute: "2-digit",
+                }) +
+                "</td>";
+        table +=
+            "<td>" +
+                cycle.part +
+                "-" +
+                LazySeq.of(cycle.material)
+                    .map((m) => m.proc)
+                    .distinctAndSortBy((p) => p)
+                    .toRArray()
+                    .join(":") +
+                "</td>";
+        table += "<td>" + stat_name_and_num(cycle.stationGroup, cycle.stationNumber) + "</td>";
+        table += "<td>" + cycle.pallet.toString() + "</td>";
+        table +=
+            "<td>" +
+                cycle.material
+                    .filter((m) => m.serial)
+                    .map((m) => m.serial)
+                    .join(",") +
+                "</td>";
+        table +=
+            "<td>" +
+                cycle.material
+                    .filter((m) => m.workorder)
+                    .map((m) => m.workorder)
+                    .join(",") +
+                "</td>";
+        table += "<td>" + format_cycle_inspection(cycle, matsById) + "</td>";
+        table += "<td>" + (cycle.elapsedMinsPerMaterial * cycle.material.length).toFixed(1) + "</td>";
+        table += "<td>" + cycle.activeMinutes.toFixed(1) + "</td>";
+        if (!hideMedian) {
+            table += "<td>" + cycle.medianCycleMinutes.toFixed(1) + "</td>";
+            table += "<td>" + cycle.MAD_aboveMinutes.toFixed(1) + "</td>";
+        }
+        table += "</tr>\n";
+    }
+    table += "</tbody>\n</table>";
+    return table;
+}
+export function copyCyclesToClipboard(cycles, matsById, zoom, hideMedian) {
+    copy(buildCycleTable(cycles, matsById, zoom ? zoom.start : undefined, zoom ? zoom.end : undefined, hideMedian));
+}
+export function buildPalletCycleTable(points) {
+    let table = "<table>\n<thead><tr>";
+    table += "<th>Pallet</th><th>Date</th><th>Elapsed (min)</th>";
+    table += "</tr></thead>\n<tbody>\n";
+    const pals = points.keysToLazySeq().toSortedArray((x) => x);
+    for (const pal of pals) {
+        for (const cycle of points.get(pal)?.valuesToLazySeq() ?? []) {
+            table += "<tr>";
+            table += "<td>" + pal.toString() + "</td>";
+            table +=
+                "<td>" +
+                    cycle.x.toLocaleString(undefined, {
+                        month: "short",
+                        day: "numeric",
+                        year: "numeric",
+                        hour: "numeric",
+                        minute: "2-digit",
+                    }) +
+                    "</td>";
+            table += "<td>" + cycle.y.toFixed(1) + "</td>";
+            table += "</tr>\n";
+        }
+    }
+    table += "</tbody>\n</table>";
+    return table;
+}
+export function copyPalletCyclesToClipboard(points) {
+    copy(buildPalletCycleTable(points));
+}
+function stat_name(e) {
+    switch (e.type) {
+        case api.LogType.LoadUnloadCycle:
+        case api.LogType.MachineCycle:
+            return e.loc + " #" + e.locnum.toString();
+        case api.LogType.AddToQueue:
+        case api.LogType.RemoveFromQueue:
+            return e.loc;
+        case api.LogType.PartMark:
+            return "Mark";
+        case api.LogType.OrderAssignment:
+            return "Workorder";
+        case api.LogType.CloseOut:
+            return "CloseOut";
+        case api.LogType.Inspection: {
+            const inspName = (e.details || {}).InspectionType || "";
+            return "Signal " + inspName;
+        }
+        case api.LogType.InspectionForce:
+            return "Signal " + e.program;
+        case api.LogType.InspectionResult:
+            return "Inspect " + e.program;
+        default:
+            return e.loc;
+    }
+}
+function result(e) {
+    switch (e.type) {
+        case api.LogType.Inspection:
+        case api.LogType.InspectionForce:
+        case api.LogType.LoadUnloadCycle:
+        case api.LogType.PartMark:
+        case api.LogType.OrderAssignment:
+            return e.result;
+        case api.LogType.AddToQueue:
+            return "Add";
+        case api.LogType.RemoveFromQueue:
+            return "Remove";
+        case api.LogType.MachineCycle:
+            return e.program;
+        case api.LogType.InspectionResult:
+            if (e.result.toLowerCase() === "false") {
+                return "Failed";
+            }
+            else {
+                return "Succeeded";
+            }
+        default:
+            return "";
+    }
+}
+export function buildLogEntriesTable(cycles) {
+    let table = "<table>\n<thead><tr>";
+    table += "<th>Date</th><th>Part</th><th>Station</th><th>Pallet</th>";
+    table += "<th>Serial</th><th>Workorder</th><th>Result</th><th>Elapsed Min</th><th>Active Min</th>";
+    table += "</tr></thead>\n<tbody>\n";
+    for (const cycle of cycles) {
+        if (cycle.startofcycle) {
+            continue;
+        }
+        for (const mat of cycle.material) {
+            table += "<tr>";
+            table +=
+                "<td>" +
+                    cycle.endUTC.toLocaleString(undefined, {
+                        month: "short",
+                        day: "numeric",
+                        year: "numeric",
+                        hour: "numeric",
+                        minute: "2-digit",
+                    }) +
+                    "</td>";
+            table += "<td>" + mat.part + "-" + mat.proc.toString() + "</td>";
+            table += "<td>" + stat_name(cycle) + "</td>";
+            table += "<td>" + cycle.pal.toString() + "</td>";
+            table += "<td>" + (mat.serial || "") + "</td>";
+            table += "<td>" + (mat.workorder || "") + "</td>";
+            table += "<td>" + result(cycle) + "</td>";
+            table += "<td>" + durationToMinutes(cycle.elapsed).toFixed(1) + "</td>";
+            table += "<td>" + durationToMinutes(cycle.active).toFixed(1) + "</td>";
+            table += "</tr>\n";
+        }
+    }
+    table += "</tbody>\n</table>";
+    return table;
+}
+export function copyLogEntriesToClipboard(cycles) {
+    copy(buildLogEntriesTable(cycles));
+}

package/dist/data/results.inspection.d.ts

@@ -0,0 +1,36 @@
+import * as api from "../network/api.js";
+import { InspectionLogEntry } from "../cell-status/inspections.js";
+import { ToComparable } from "@seedtactics/immutable-collections";
+export interface TriggeredInspectionEntry {
+    readonly time: Date;
+    readonly materialID: number;
+    readonly partName: string;
+    readonly serial?: string;
+    readonly workorder?: string;
+    readonly toInspect: boolean;
+    readonly path: string;
+    readonly failed: boolean;
+}
+export declare function buildPathString(procs: ReadonlyArray<Readonly<api.IMaterialProcessActualPath>>): string;
+export interface InspectionsForPath {
+    readonly material: ReadonlyArray<TriggeredInspectionEntry>;
+    readonly failedCnt: number;
+}
+export declare function groupInspectionsByPath(entries: Iterable<InspectionLogEntry>, dateRange: {
+    start: Date;
+    end: Date;
+} | undefined, sortOn: ToComparable<TriggeredInspectionEntry>): ReadonlyMap<string, InspectionsForPath>;
+export interface FailedInspectionEntry {
+    readonly time: Date;
+    readonly materialID: number;
+    readonly serial?: string;
+    readonly workorder?: string;
+    readonly inspType: string;
+    readonly part: string;
+}
+export declare function extractFailedInspections(entries: Iterable<InspectionLogEntry>, start: Date, end: Date): ReadonlyArray<FailedInspectionEntry>;
+export declare function extractPath(evts: ReadonlyArray<Readonly<api.ILogEntry>>): ReadonlyArray<Readonly<api.IMaterialProcessActualPath>>;
+export declare function buildInspectionTable(part: string, inspType: string, entries: Iterable<InspectionLogEntry>): string;
+export declare function copyInspectionEntriesToClipboard(part: string, inspType: string, entries: Iterable<InspectionLogEntry>): void;
+export declare function buildFailedInspTable(entries: Iterable<FailedInspectionEntry>): string;
+export declare function copyFailedInspectionsToClipboard(entries: Iterable<FailedInspectionEntry>): void;

package/dist/data/results.inspection.js

@@ -0,0 +1,188 @@
+/* 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 { InspectionLogResultType } from "../cell-status/inspections.js";
+import { LazySeq, mkCompareByProperties } from "@seedtactics/immutable-collections";
+import copy from "copy-to-clipboard";
+export function buildPathString(procs) {
+    const pathStrs = [];
+    for (const proc of procs) {
+        for (const stop of proc.stops) {
+            pathStrs.push("P" + proc.pallet.toString() + "," + "M" + stop.stationNum.toString());
+        }
+    }
+    return pathStrs.join(" -> ");
+}
+export function groupInspectionsByPath(entries, dateRange, sortOn) {
+    const failed = LazySeq.of(entries)
+        .collect((e) => {
+        if (e.result.type === InspectionLogResultType.Completed && !e.result.success) {
+            return e.materialID;
+        }
+        else {
+            return null;
+        }
+    })
+        .toRSet((e) => e);
+    return LazySeq.of(entries)
+        .collect((e) => {
+        if (dateRange && (e.time < dateRange.start || e.time > dateRange.end)) {
+            return null;
+        }
+        switch (e.result.type) {
+            case InspectionLogResultType.Triggered:
+                return {
+                    time: e.time,
+                    materialID: e.materialID,
+                    partName: e.part,
+                    serial: e.serial,
+                    workorder: e.workorder,
+                    toInspect: e.result.toInspect,
+                    path: buildPathString(e.result.actualPath),
+                    failed: failed.has(e.materialID),
+                };
+            default:
+                return null;
+        }
+    })
+        .buildHashMap((e) => e.path, (old, e) => {
+        const a = old ?? [];
+        a.push(e);
+        return a;
+    })
+        .mapValues((mats) => ({
+        material: mats.sort(mkCompareByProperties(sortOn, (e) => e.time.getTime())),
+        failedCnt: mats.reduce((acc, e) => acc + (e.failed ? 1 : 0), 0),
+    }));
+}
+export function extractFailedInspections(entries, start, end) {
+    return LazySeq.of(entries)
+        .collect((e) => {
+        if (e.time < start || e.time > end) {
+            return null;
+        }
+        if (e.result.type === InspectionLogResultType.Completed && !e.result.success) {
+            return {
+                time: e.time,
+                materialID: e.materialID,
+                serial: e.serial,
+                workorder: e.workorder,
+                inspType: e.inspType,
+                part: e.part,
+            };
+        }
+        else {
+            return null;
+        }
+    })
+        .toSortedArray((e) => e.time.getTime());
+}
+// --------------------------------------------------------------------------------
+// Failed Lookup
+// --------------------------------------------------------------------------------
+export function extractPath(evts) {
+    for (const e of evts) {
+        if (e.type === api.LogType.Inspection) {
+            const pathsJson = JSON.parse((e.details || {}).ActualPath || "[]");
+            const paths = [];
+            for (const pathJson of pathsJson) {
+                paths.push(api.MaterialProcessActualPath.fromJS(pathJson));
+            }
+            if (paths.length > 0) {
+                return paths;
+            }
+        }
+    }
+    return [];
+}
+// --------------------------------------------------------------------------------
+// Clipboard
+// --------------------------------------------------------------------------------
+export function buildInspectionTable(part, inspType, entries) {
+    let table = "<table>\n<thead><tr>";
+    table += "<th>Path</th><th>Date</th><th>Part</th><th>Inspection</th>";
+    table += "<th>Serial</th><th>Workorder</th><th>Inspected</th><th>Failed</th>";
+    table += "</tr></thead>\n<tbody>\n";
+    const groups = groupInspectionsByPath(entries, undefined, { asc: (e) => e.time.getTime() });
+    const paths = LazySeq.of(groups.keys()).toSortedArray((x) => x);
+    for (const path of paths) {
+        const data = groups.get(path);
+        if (data) {
+            for (const mat of data.material) {
+                table += "<tr>";
+                table += "<td>" + path + "</td>";
+                table +=
+                    "<td>" +
+                        mat.time.toLocaleString(undefined, {
+                            month: "short",
+                            day: "numeric",
+                            year: "numeric",
+                            hour: "numeric",
+                            minute: "2-digit",
+                        }) +
+                        "</td>";
+                table += "<td>" + part + "</td>";
+                table += "<td>" + inspType + "</td>";
+                table += "<td>" + (mat.serial || "") + "</td>";
+                table += "<td>" + (mat.workorder || "") + "</td>";
+                table += "<td>" + (mat.toInspect ? "inspected" : "") + "</td>";
+                table += "<td>" + (mat.failed ? "failed" : "") + "</td>";
+                table += "</tr>\n";
+            }
+        }
+    }
+    table += "</tbody>\n</table>";
+    return table;
+}
+export function copyInspectionEntriesToClipboard(part, inspType, entries) {
+    copy(buildInspectionTable(part, inspType, entries));
+}
+export function buildFailedInspTable(entries) {
+    let table = "<table>\n<thead><tr>";
+    table += "<th>Date</th><th>Part</th><th>Inspection</th><th>Serial</th><th>Workorder</th>";
+    table += "</tr></thead>\n<tbody>\n";
+    for (const e of LazySeq.of(entries).sortBy({ desc: (x) => x.time.getTime() })) {
+        table += "<tr>";
+        table += "<td>" + e.time.toLocaleString() + "</td>";
+        table += "<td>" + e.part + "</td>";
+        table += "<td>" + e.inspType + "</td>";
+        table += "<td>" + (e.serial || "") + "</td>";
+        table += "<td>" + (e.workorder || "") + "</td>";
+        table += "</tr>\n";
+    }
+    table += "</tbody>\n</table>";
+    return table;
+}
+export function copyFailedInspectionsToClipboard(entries) {
+    copy(buildFailedInspTable(entries));
+}