@seedtactics/insight-client 16.5.2 → 16.7.0

package/dist/data/queue-material.js

@@ -31,7 +31,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 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 { LazySeq, OrderedMap } from "@seedtactics/immutable-collections";
 import { LogBackend } from "../network/backend.js";
 import { differenceInSeconds } from "date-fns";
 import { useAtomValue } from "jotai";
@@ -150,9 +150,6 @@ export function extractJobRawMaterial(jobs, mats, queue) {
         return prec;
     });
 }
-function compareByQueuePos(m1, m2) {
-    return (m1.location.queuePosition ?? 10000000000) - (m2.location.queuePosition ?? 10000000000);
-}
 export function selectQueueData(queuesToCheck, curSt, rawMatQueues, inProcQueues) {
     const queues = [];
     const queueNames = [...queuesToCheck];
@@ -160,12 +157,14 @@ export function selectQueueData(queuesToCheck, curSt, rawMatQueues, inProcQueues
     for (const queueName of queueNames) {
         const isRawMat = rawMatQueues.has(queueName);
         if (isRawMat) {
-            const material = [];
+            const materialByPos = OrderedMap.empty();
             const matByPartThenUniq = new Map();
             for (const m of curSt.material) {
-                if (m.location.type === api.LocType.InQueue && m.location.currentQueue === queueName) {
+                if (m.location.type === api.LocType.InQueue &&
+                    m.location.currentQueue === queueName &&
+                    m.location.queuePosition !== undefined) {
                     if ((m.serial && m.serial !== "") || m.action.type !== api.ActionType.Waiting) {
-                        material.push(m);
+                        materialByPos.set(m.location.queuePosition, m);
                     }
                     else {
                         let matsForPart = matByPartThenUniq.get(m.partName);
@@ -208,7 +207,7 @@ export function selectQueueData(queuesToCheck, curSt, rawMatQueues, inProcQueues
                 free: false,
                 rawMaterialQueue: true,
                 inProcQueue: false,
-                material: material.sort(compareByQueuePos),
+                material: [...materialByPos.values()],
                 groupedRawMat: matGroups,
             });
         }
@@ -218,17 +217,19 @@ export function selectQueueData(queuesToCheck, curSt, rawMatQueues, inProcQueues
                 free: false,
                 rawMaterialQueue: false,
                 inProcQueue: inProcQueues.has(queueName),
-                material: curSt.material
-                    .filter((m) => m.location.type === api.LocType.InQueue && m.location.currentQueue === queueName)
-                    .sort(compareByQueuePos),
+                material: LazySeq.of(curSt.material)
+                    .filter((m) => m.location.type === api.LocType.InQueue &&
+                    m.location.currentQueue === queueName &&
+                    m.location.queuePosition !== undefined)
+                    .toSortedArray((m) => m.location.queuePosition ?? 0),
             });
         }
     }
     return queues;
 }
-export async function loadRawMaterialEvents(material) {
+export async function loadRawMaterialEvents(materials) {
     const events = [];
-    for (const chunk of LazySeq.of(material).chunk(15)) {
+    for (const chunk of LazySeq.of(materials).chunk(15)) {
         events.push(...(await LogBackend.logForMaterials(chunk.map((m) => m.materialID))));
     }
     events.sort((a, b) => a.endUTC.getTime() - b.endUTC.getTime());
@@ -236,18 +237,18 @@ export async function loadRawMaterialEvents(material) {
     for (let i = 0; i < events.length; i++) {
         const evt = events[i];
         if (evt.type === api.LogType.AddToQueue || evt.type === api.LogType.RemoveFromQueue) {
-            const material = [...evt.material];
+            const groupedMaterial = [...evt.material];
             while (i + 1 < events.length &&
                 events[i + 1].type === evt.type &&
                 differenceInSeconds(events[i + 1].endUTC, evt.endUTC) < 10) {
-                material.push(...events[i + 1].material);
+                groupedMaterial.push(...events[i + 1].material);
                 i += 1;
             }
-            if (material.length === evt.material.length) {
+            if (groupedMaterial.length === evt.material.length) {
                 groupedEvents.push(evt);
             }
             else {
-                groupedEvents.push({ ...evt, material: material });
+                groupedEvents.push({ ...evt, material: groupedMaterial });
             }
         }
         else {

package/dist/data/results.completed-parts.js

@@ -32,6 +32,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import { startOfDay } from "date-fns";
 import copy from "copy-to-clipboard";
+import { isMachineCycle } from "../cell-status/station-cycles.js";
 import { hashValues, LazySeq } from "@seedtactics/immutable-collections";
 // --------------------------------------------------------------------------------
 // Actual
@@ -85,7 +86,7 @@ export function binCyclesByDayAndPart(cycles, matsById, start, end) {
     const activeTimeByMatId = LazySeq.of(cycles)
         .filter((cycle) => cycle.endTime >= start &&
         cycle.endTime <= end &&
-        !cycle.isLabor &&
+        isMachineCycle(cycle) &&
         cycle.activeMinutes > 0 &&
         cycle.material.length > 0)
         .flatMap((cycle) => cycle.material.map((mat) => ({
@@ -99,7 +100,7 @@ export function binCyclesByDayAndPart(cycles, matsById, start, end) {
         .filter(([_, unloadTime]) => unloadTime >= start && unloadTime <= end)
         .map(([proc, unloadTime]) => ({
         day: startOfDay(unloadTime),
-        part: details.partName + "-" + proc.toString(),
+        part: details.partName + "-" + proc,
         value: {
             count: 1,
             activeMachineMins: activeTimeByMatId.get(new MatIdAndProcess(matId, parseInt(proc))) ?? 0,
@@ -177,5 +178,5 @@ export function buildCompletedPartsHeatmapTable(points) {
     return table;
 }
 export function copyCompletedPartsHeatmapToClipboard(points) {
-    copy(buildCompletedPartsHeatmapTable(points));
+    void copy(buildCompletedPartsHeatmapTable(points));
 }

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

@@ -14,7 +14,10 @@ export interface CycleFilterOptions {
     readonly allLoadStationNames: ReadonlyArray<string>;
     readonly allMachineNames: ReadonlyArray<string>;
     readonly allMachineOperations: ReadonlyArray<PartAndStationOperation>;
+    readonly hasBasketCycles: boolean;
 }
+export type CarrierKindFilter = "Any" | "Pallet" | "Basket";
+export declare function normalizeCarrierKindFilter(carrierKind: CarrierKindFilter | undefined, hasBasketCycles: boolean): CarrierKindFilter | undefined;
 export type PartCycleChartData = PartCycleData & {
     readonly x: Date;
     readonly y: number;
@@ -34,9 +37,10 @@ export interface StationCycleFilter {
     readonly pallet?: number;
     readonly station?: string;
     readonly operation?: PartAndStationOperation;
+    readonly carrierKind?: CarrierKindFilter;
 }
 export declare function emptyStationCycles(allCycles: Iterable<PartCycleData>): FilteredStationCycles & CycleFilterOptions;
-export declare function filterStationCycles(allCycles: Iterable<PartCycleData>, { zoom, partAndProc, pallet, station, operation }: StationCycleFilter): FilteredStationCycles & CycleFilterOptions;
+export declare function filterStationCycles(allCycles: Iterable<PartCycleData>, { zoom, partAndProc, pallet, station, operation, carrierKind }: StationCycleFilter): FilteredStationCycles & CycleFilterOptions;
 export interface LoadCycleData extends PartCycleChartData {
     readonly operations?: ReadonlyArray<{
         readonly mat: Readonly<api.ILogMaterial>;
@@ -55,8 +59,9 @@ export interface LoadCycleFilter {
     readonly partAndProc?: PartAndProcess;
     readonly pallet?: number;
     readonly station?: string;
+    readonly carrierKind?: CarrierKindFilter;
 }
-export declare function loadOccupancyCycles(allCycles: Iterable<PartCycleData>, { zoom, partAndProc, pallet, station }: LoadCycleFilter): FilteredLoadCycles & CycleFilterOptions;
+export declare function loadOccupancyCycles(allCycles: Iterable<PartCycleData>, { zoom, partAndProc, pallet, station, carrierKind }: LoadCycleFilter): FilteredLoadCycles & CycleFilterOptions;
 export declare function plannedOperationMinutes(s: FilteredStationCycles, forSingleMat: boolean): number | undefined;
 export interface RecentCycle {
     readonly station: string;
@@ -75,12 +80,16 @@ export type ClipboardStationCycles = {
     readonly seriesLabel: string;
     readonly data: ReadonlyMap<string, ReadonlyArray<PartCycleData>>;
 };
-export declare function buildCycleTable(cycles: ClipboardStationCycles, matsById: HashMap<number, MaterialSummaryAndCompletedData>, startD: Date | undefined, endD: Date | undefined, hideMedian?: boolean): string;
+export declare function buildCycleTable(cycles: ClipboardStationCycles, matsById: HashMap<number, MaterialSummaryAndCompletedData>, startD: Date | undefined, endD: Date | undefined, hideMedian?: boolean, loadStationNames?: {
+    [key: string]: string;
+}, basketName?: string): string;
 export declare function copyCyclesToClipboard(cycles: ClipboardStationCycles, matsById: HashMap<number, MaterialSummaryAndCompletedData>, zoom: {
     start: Date;
     end: Date;
-} | undefined, hideMedian?: boolean): void;
-export declare function buildPalletCycleTable(points: PalletCyclesByPallet): string;
-export declare function copyPalletCyclesToClipboard(points: PalletCyclesByPallet): void;
+} | undefined, hideMedian?: boolean, loadStationNames?: {
+    [key: string]: string;
+}, basketName?: string): void;
+export declare function buildPalletCycleTable(points: PalletCyclesByPallet, carrierColumnLabel?: string): string;
+export declare function copyPalletCyclesToClipboard(points: PalletCyclesByPallet, carrierColumnLabel?: string): void;
 export declare function buildLogEntriesTable(cycles: Iterable<Readonly<api.ILogEntry>>): string;
 export declare function copyLogEntriesToClipboard(cycles: Iterable<Readonly<api.ILogEntry>>): void;

package/dist/data/results.cycles.js

@@ -35,21 +35,29 @@ 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 { basketDisplayName, basketForCycle, carrierLabel, displayStationName, isBasketLoadCycle, isLaborCycle, palletForCycle, } from "../cell-status/station-cycles.js";
 import { LazySeq, OrderedSet, OrderedMap } from "@seedtactics/immutable-collections";
+export function normalizeCarrierKindFilter(carrierKind, hasBasketCycles) {
+    return !hasBasketCycles && carrierKind === "Basket" ? "Any" : carrierKind;
+}
 function extractFilterOptions(cycles, selectedPart) {
     let palNames = OrderedSet.empty();
     let lulNames = OrderedSet.empty();
     let mcNames = OrderedSet.empty();
     let partNames = OrderedMap.empty();
     let oper = OrderedSet.empty();
+    let hasBasket = false;
     for (const c of cycles) {
-        palNames = palNames.add(c.pallet);
-        if (c.isLabor) {
-            lulNames = lulNames.add(stat_name_and_num(c.stationGroup, c.stationNumber));
+        const pallet = palletForCycle(c);
+        if (pallet !== undefined) {
+            palNames = palNames.add(pallet);
+        }
+        hasBasket = hasBasket || isBasketLoadCycle(c);
+        if (isLaborCycle(c)) {
+            lulNames = lulNames.add(c.stationLabel);
         }
         else {
-            mcNames = mcNames.add(stat_name_and_num(c.stationGroup, c.stationNumber));
+            mcNames = mcNames.add(c.stationLabel);
             if (selectedPart &&
                 c.part == selectedPart.part &&
                 c.material.some((m) => m.proc === selectedPart.proc)) {
@@ -69,6 +77,7 @@ function extractFilterOptions(cycles, selectedPart) {
             .flatMap(([part, procs]) => procs.toAscLazySeq().map((proc) => ({ part: part, proc: proc })))
             .toRArray(),
         allMachineOperations: oper.toAscLazySeq().toRArray(),
+        hasBasketCycles: hasBasket,
     };
 }
 export const FilterAnyMachineKey = "@@@_FMSInsight_FilterAnyMachineKey_@@@";
@@ -80,12 +89,12 @@ export function emptyStationCycles(allCycles) {
         data: new Map(),
     };
 }
-export function filterStationCycles(allCycles, { zoom, partAndProc, pallet, station, operation }) {
+export function filterStationCycles(allCycles, { zoom, partAndProc, pallet, station, operation, carrierKind }) {
     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",
+        seriesLabel: groupByPal ? "Carrier" : groupByPart ? "Part" : "Station",
         data: LazySeq.of(allCycles)
             .filter((e) => {
             if (zoom && (e.endTime < zoom.start || e.endTime > zoom.end)) {
@@ -95,20 +104,26 @@ export function filterStationCycles(allCycles, { zoom, partAndProc, pallet, stat
                 (e.part !== partAndProc.part || !e.material.some((m) => m.proc === partAndProc.proc))) {
                 return false;
             }
-            if (pallet && e.pallet !== pallet) {
+            if (pallet && palletForCycle(e) !== pallet) {
+                return false;
+            }
+            if (carrierKind === "Pallet" && basketForCycle(e) !== undefined) {
+                return false;
+            }
+            if (carrierKind === "Basket" && basketForCycle(e) === undefined) {
                 return false;
             }
             if (station === FilterAnyMachineKey) {
-                if (e.isLabor) {
+                if (isLaborCycle(e)) {
                     return false;
                 }
             }
             else if (station === FilterAnyLoadKey) {
-                if (!e.isLabor) {
+                if (!isLaborCycle(e)) {
                     return false;
                 }
             }
-            else if (station && stat_name_and_num(e.stationGroup, e.stationNumber) !== station) {
+            else if (station && e.stationLabel !== station) {
                 return false;
             }
             if (operation && operation.compare(PartAndStationOperation.ofPartCycle(e)) !== 0) {
@@ -118,7 +133,7 @@ export function filterStationCycles(allCycles, { zoom, partAndProc, pallet, stat
         })
             .toRLookup((e) => {
             if (groupByPal) {
-                return e.pallet.toString();
+                return carrierLabel(e);
             }
             else if (groupByPart) {
                 return (e.part +
@@ -130,7 +145,7 @@ export function filterStationCycles(allCycles, { zoom, partAndProc, pallet, stat
                         .join(":"));
             }
             else {
-                return stat_name_and_num(e.stationGroup, e.stationNumber);
+                return e.stationLabel;
             }
         }, (e) => ({
             ...e,
@@ -139,19 +154,25 @@ export function filterStationCycles(allCycles, { zoom, partAndProc, pallet, stat
         })),
     };
 }
-export function loadOccupancyCycles(allCycles, { zoom, partAndProc, pallet, station }) {
+export function loadOccupancyCycles(allCycles, { zoom, partAndProc, pallet, station, carrierKind }) {
     const filteredCycles = LazySeq.of(allCycles).filter((e) => {
+        if (carrierKind === "Pallet" && basketForCycle(e) !== undefined) {
+            return false;
+        }
+        if (carrierKind === "Basket" && basketForCycle(e) === undefined) {
+            return false;
+        }
         if (!station || station === FilterAnyLoadKey) {
-            return e.isLabor;
+            return isLaborCycle(e);
         }
         else {
-            return stat_name_and_num(e.stationGroup, e.stationNumber) === station;
+            return isLaborCycle(e) && e.stationLabel === station;
         }
     });
     return {
         ...extractFilterOptions(allCycles, partAndProc),
         seriesLabel: "Station",
-        data: chunkCyclesWithSimilarEndTime(filteredCycles, (c) => stat_name_and_num(c.stationGroup, c.stationNumber), (c) => c.endTime)
+        data: chunkCyclesWithSimilarEndTime(filteredCycles, (c) => c.stationLabel, (c) => c.endTime)
             .map(([statNameAndNum, cyclesForStat]) => [
             statNameAndNum,
             LazySeq.of(cyclesForStat)
@@ -164,7 +185,7 @@ export function loadOccupancyCycles(allCycles, { zoom, partAndProc, pallet, stat
                         (e.part !== partAndProc.part || !e.material.some((m) => m.proc === partAndProc.proc))) {
                         return false;
                     }
-                    if (pallet && e.pallet !== pallet) {
+                    if (pallet && palletForCycle(e) !== pallet) {
                         return false;
                     }
                     return true;
@@ -207,7 +228,7 @@ export function plannedOperationMinutes(s, forSingleMat) {
     return planned?.mins;
 }
 export function recentCycles(allCycles) {
-    return chunkCyclesWithSimilarEndTime(allCycles, (c) => stat_name_and_num(c.stationGroup, c.stationNumber), (c) => c.endTime)
+    return chunkCyclesWithSimilarEndTime(allCycles, (c) => c.stationLabel, (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
@@ -268,9 +289,9 @@ export function format_cycle_inspection(c, matsById) {
     }
     return ret.join(", ");
 }
-export function buildCycleTable(cycles, matsById, startD, endD, hideMedian) {
+export function buildCycleTable(cycles, matsById, startD, endD, hideMedian, loadStationNames, basketName) {
     let table = "<table>\n<thead><tr>";
-    table += "<th>Date</th><th>Part</th><th>Station</th><th>Pallet</th>";
+    table += "<th>Date</th><th>Part</th><th>Station</th><th>Carrier</th>";
     table += "<th>Serial</th><th>Workorder</th><th>Inspection</th>";
     table += "<th>Elapsed Min</th><th>Target Min</th>";
     if (!hideMedian) {
@@ -303,8 +324,8 @@ export function buildCycleTable(cycles, matsById, startD, endD, hideMedian) {
                     .toRArray()
                     .join(":") +
                 "</td>";
-        table += "<td>" + stat_name_and_num(cycle.stationGroup, cycle.stationNumber) + "</td>";
-        table += "<td>" + cycle.pallet.toString() + "</td>";
+        table += "<td>" + displayStationName(cycle.stationGroup, cycle.stationNumber, loadStationNames) + "</td>";
+        table += "<td>" + carrierLabel(cycle, basketDisplayName(basketName)) + "</td>";
         table +=
             "<td>" +
                 cycle.material
@@ -331,12 +352,12 @@ export function buildCycleTable(cycles, matsById, startD, endD, hideMedian) {
     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 copyCyclesToClipboard(cycles, matsById, zoom, hideMedian, loadStationNames, basketName) {
+    copy(buildCycleTable(cycles, matsById, zoom ? zoom.start : undefined, zoom ? zoom.end : undefined, hideMedian, loadStationNames, basketName)).catch(console.error);
 }
-export function buildPalletCycleTable(points) {
+export function buildPalletCycleTable(points, carrierColumnLabel = "Pallet") {
     let table = "<table>\n<thead><tr>";
-    table += "<th>Pallet</th><th>Date</th><th>Elapsed (min)</th>";
+    table += `<th>${carrierColumnLabel}</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) {
@@ -360,8 +381,8 @@ export function buildPalletCycleTable(points) {
     table += "</tbody>\n</table>";
     return table;
 }
-export function copyPalletCyclesToClipboard(points) {
-    copy(buildPalletCycleTable(points));
+export function copyPalletCyclesToClipboard(points, carrierColumnLabel = "Pallet") {
+    copy(buildPalletCycleTable(points, carrierColumnLabel)).catch(console.error);
 }
 function stat_name(e) {
     switch (e.type) {
@@ -450,5 +471,5 @@ export function buildLogEntriesTable(cycles) {
     return table;
 }
 export function copyLogEntriesToClipboard(cycles) {
-    copy(buildLogEntriesTable(cycles));
+    copy(buildLogEntriesTable(cycles)).catch(console.error);
 }

package/dist/data/results.inspection.js

@@ -32,13 +32,13 @@ 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 { LazySeq } 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());
+            pathStrs.push(`P${proc.pallet},M${stop.stationNum}`);
         }
     }
     return pathStrs.join(" -> ");
@@ -81,7 +81,7 @@ export function groupInspectionsByPath(entries, dateRange, sortOn) {
         return a;
     })
         .mapValues((mats) => ({
-        material: mats.sort(mkCompareByProperties(sortOn, (e) => e.time.getTime())),
+        material: LazySeq.of(mats).toSortedArray(sortOn, (e) => e.time.getTime()),
         failedCnt: mats.reduce((acc, e) => acc + (e.failed ? 1 : 0), 0),
     }));
 }
@@ -114,9 +114,14 @@ export function extractPath(evts) {
     for (const e of evts) {
         if (e.type === api.LogType.Inspection) {
             const pathsJson = JSON.parse((e.details || {}).ActualPath || "[]");
+            if (!Array.isArray(pathsJson)) {
+                continue;
+            }
             const paths = [];
             for (const pathJson of pathsJson) {
-                paths.push(api.MaterialProcessActualPath.fromJS(pathJson));
+                if (typeof pathJson === "object" && pathJson !== null) {
+                    paths.push(api.MaterialProcessActualPath.fromJS(pathJson));
+                }
             }
             if (paths.length > 0) {
                 return paths;
@@ -165,7 +170,7 @@ export function buildInspectionTable(part, inspType, entries) {
     return table;
 }
 export function copyInspectionEntriesToClipboard(part, inspType, entries) {
-    copy(buildInspectionTable(part, inspType, entries));
+    void copy(buildInspectionTable(part, inspType, entries));
 }
 export function buildFailedInspTable(entries) {
     let table = "<table>\n<thead><tr>";
@@ -184,5 +189,5 @@ export function buildFailedInspTable(entries) {
     return table;
 }
 export function copyFailedInspectionsToClipboard(entries) {
-    copy(buildFailedInspTable(entries));
+    void copy(buildFailedInspTable(entries));
 }

package/dist/data/results.oee.js

@@ -33,7 +33,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import { startOfDay, addSeconds, addDays, max, min, differenceInMinutes } from "date-fns";
 import copy from "copy-to-clipboard";
 import { chunkCyclesWithSimilarEndTime } from "../cell-status/estimated-cycle-times.js";
-import { stat_name_and_num } from "../cell-status/station-cycles.js";
+import { isLaborCycle } from "../cell-status/station-cycles.js";
 import { hashValues, LazySeq } from "@seedtactics/immutable-collections";
 // --------------------------------------------------------------------------------
 // Actual
@@ -86,7 +86,7 @@ function splitTimeToDays(startTime, endTime, mins) {
     }
 }
 function binCycles(cycles, f) {
-    return chunkCyclesWithSimilarEndTime(LazySeq.of(cycles), (c) => stat_name_and_num(c.stationGroup, c.stationNumber), (c) => c.endTime)
+    return chunkCyclesWithSimilarEndTime(LazySeq.of(cycles), (c) => c.stationLabel, (c) => c.endTime)
         .flatMap(([statNameAndNum, cyclesForStat]) => cyclesForStat
         .flatMap((chunk) => {
         // sum elapsed time for chunk and subtract from end time to get start time
@@ -135,7 +135,7 @@ function mergeSortedIntervals(intervals) {
 export function binDowntimeToDayAndStat(simUses) {
     return LazySeq.of(simUses)
         .filter((simUse) => simUse.plannedDown)
-        .toLookupOrderedMap((simUse) => simUse.station, (simUse) => simUse.start)
+        .toLookupOrderedMap((simUse) => simUse.stationLabel, (simUse) => simUse.start)
         .toAscLazySeq()
         .flatMap(([station, uses]) => mergeSortedIntervals(uses.valuesToAscLazySeq()).flatMap((simUse) => splitTimeToDays(simUse.start, simUse.end, differenceInMinutes(simUse.end, simUse.start)).map((x) => ({
         ...x,
@@ -146,11 +146,11 @@ export function binDowntimeToDayAndStat(simUses) {
 export function binSimStationUseByDayAndStat(simUses) {
     const downtimes = LazySeq.of(simUses)
         .filter((simUse) => simUse.plannedDown)
-        .toLookupOrderedMap((simUse) => simUse.station, (simUse) => simUse.start)
+        .toLookupOrderedMap((simUse) => simUse.stationLabel, (simUse) => simUse.start)
         .mapValues((uses) => mergeSortedIntervals(uses.valuesToAscLazySeq()));
     return LazySeq.of(simUses)
         .filter((simUse) => !simUse.plannedDown)
-        .toLookupOrderedMap((simUse) => simUse.station, (simUse) => simUse.start)
+        .toLookupOrderedMap((simUse) => simUse.stationLabel, (simUse) => simUse.start)
         .toAscLazySeq()
         .flatMap(([station, uses]) => {
         const sorted = mergeSortedIntervals(uses.valuesToAscLazySeq());
@@ -220,7 +220,7 @@ export function binSimStationUseByDayAndStat(simUses) {
         .toHashMap((s) => [new DayAndStation(s.day, s.station), s.value], (v1, v2) => v1 + v2);
 }
 export function buildOeeSeries(start, end, ty, cycles, statUse) {
-    const filteredCycles = LazySeq.of(cycles).filter((e) => (ty === "labor") === e.isLabor && e.endTime >= start && e.endTime <= end);
+    const filteredCycles = LazySeq.of(cycles).filter((e) => (ty === "labor") === isLaborCycle(e) && e.endTime >= start && e.endTime <= end);
     const actualBins = binActiveCyclesByDayAndStat(filteredCycles);
     const filteredStatUse = LazySeq.of(statUse).filter((e) => (ty === "labor") === e.station.startsWith("L/U") && e.end >= start && e.start <= end);
     const downtimes = binDowntimeToDayAndStat(filteredStatUse);
@@ -306,7 +306,7 @@ export function buildOeeHeatmapTable(yTitle, points) {
     return table;
 }
 export function copyOeeHeatmapToClipboard(yTitle, points) {
-    copy(buildOeeHeatmapTable(yTitle, points));
+    void copy(buildOeeHeatmapTable(yTitle, points));
 }
 export function buildOeeTable(series) {
     let table = "<table>\n<thead><tr>";
@@ -326,5 +326,5 @@ export function buildOeeTable(series) {
     return table;
 }
 export function copyOeeToClipboard(series) {
-    copy(buildOeeTable(series));
+    void copy(buildOeeTable(series));
 }

package/dist/data/results.schedules.js

@@ -99,16 +99,7 @@ export function buildScheduledJobs(zoom, matIds, schJobs, currentSt) {
             }
         }
     }
-    const sorted = Array.from(result.values()).sort((j1, j2) => {
-        // sort starting time high to low, then by part
-        const timeDiff = j2.routeStartTime.getTime() - j1.routeStartTime.getTime();
-        if (timeDiff == 0) {
-            return j1.partName.localeCompare(j2.partName);
-        }
-        else {
-            return timeDiff;
-        }
-    });
+    const sorted = LazySeq.of(result.values()).toSortedArray({ desc: (j) => j.routeStartTime.getTime() }, (j) => j.partName);
     let lastSchId = null;
     let curDark = true;
     for (const job of sorted) {
@@ -153,5 +144,5 @@ export function buildScheduledJobsTable(jobs, showMaterial) {
     return table;
 }
 export function copyScheduledJobsToClipboard(jobs, showMaterial) {
-    copy(buildScheduledJobsTable(jobs, showMaterial));
+    void copy(buildScheduledJobsTable(jobs, showMaterial));
 }

package/dist/data/tools-programs.js

@@ -207,11 +207,10 @@ export const machinesWithTools = atom((get) => {
     const toolsInMach = get(toolsInMachine);
     if (toolsInMach === null)
         return [];
-    const names = new Set();
-    for (const t of toolsInMach.tools) {
-        names.add(stat_name_and_num(t.machineGroupName, t.machineNum));
-    }
-    return Array.from(names).sort((a, b) => a.localeCompare(b));
+    return LazySeq.of(toolsInMach.tools)
+        .toOrderedSet((n) => stat_name_and_num(n.machineGroupName, n.machineNum))
+        .toAscLazySeq()
+        .toRArray();
 });
 export const currentToolReport = atom((get) => {
     const toolsInMach = get(toolsInMachine);
@@ -282,7 +281,7 @@ export function useCopyToolReportToClipboard() {
         const tools = store.get(currentToolReport);
         if (!tools)
             return;
-        copy(buildToolReportHTML(tools));
+        void copy(buildToolReportHTML(tools));
     }, [store]);
 }
 export function calcProgramReport(usage, cycleTimes, jobs, progsInCellCtrl, progsToShow) {

package/dist/index.html

@@ -44,7 +44,7 @@
         }
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-gAFi3Oss.js"></script>
+    <script type="module" crossorigin src="/assets/index-bPAFn3jp.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CbqW4-gR.css">
   </head>
   <body>

package/dist/network/api.d.ts

@@ -452,6 +452,10 @@ export interface IHoldPattern {
     holdUnholdPatternRepeats: boolean;
 }
 export declare class ProcessInfo implements IProcessInfo {
+    basketLoadStations?: number[] | undefined;
+    expectedBasketLoadTime?: string | undefined;
+    basketUnloadStations?: number[] | undefined;
+    expectedBasketUnloadTime?: string | undefined;
     paths: ProcPathInfo[];
     constructor(data?: IProcessInfo);
     init(_data?: any): void;
@@ -459,6 +463,10 @@ export declare class ProcessInfo implements IProcessInfo {
     toJSON(data?: any): any;
 }
 export interface IProcessInfo {
+    basketLoadStations?: number[] | undefined;
+    expectedBasketLoadTime?: string | undefined;
+    basketUnloadStations?: number[] | undefined;
+    expectedBasketUnloadTime?: string | undefined;
     paths: ProcPathInfo[];
 }
 export declare class ProcPathInfo implements IProcPathInfo {
@@ -1030,8 +1038,10 @@ export declare enum WorkorderSerialCloseout {
 }
 export declare class BasketStatus implements IBasketStatus {
     basketId: number;
-    locationName: string;
-    locationPosition?: number | undefined;
+    location: BasketLocationEnum;
+    locationNum: number;
+    locationTitle?: string | undefined;
+    slot?: number | undefined;
     constructor(data?: IBasketStatus);
     init(_data?: any): void;
     static fromJS(data: any): BasketStatus;
@@ -1039,8 +1049,16 @@ export declare class BasketStatus implements IBasketStatus {
 }
 export interface IBasketStatus {
     basketId: number;
-    locationName: string;
-    locationPosition?: number | undefined;
+    location: BasketLocationEnum;
+    locationNum: number;
+    locationTitle?: string | undefined;
+    slot?: number | undefined;
+}
+export declare enum BasketLocationEnum {
+    LoadUnload = "LoadUnload",
+    LoadStationStaging = "LoadStationStaging",
+    Storage = "Storage",
+    InTransit = "InTransit"
 }
 export declare class EditMaterialInLogEvents implements IEditMaterialInLogEvents {
     oldMaterialID: number;