@seedtactics/insight-client 16.4.0

package/dist/data/part-summary.js

@@ -0,0 +1,107 @@
+/* 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 { LazySeq, OrderedMap, OrderedSet } from "@seedtactics/immutable-collections";
+import { last30MaterialSummary } from "../cell-status/material-summary";
+import { atom } from "jotai";
+import { last30StationCycles } from "../cell-status/station-cycles";
+import { chartRangeAtom } from "./chart-times";
+function isAbnormal(m) {
+    if (m.closeout_completed === undefined) {
+        // no closeout has been done, so fall back to checking inspections and quarantined
+        if (LazySeq.ofObject(m.completedInspections ?? {}).some(([, insp]) => insp.success === false)) {
+            return true;
+        }
+        if (m.currently_quarantined) {
+            return true;
+        }
+        return false;
+    }
+    else {
+        return m.closeout_failed !== false;
+    }
+}
+export const last30PartSummaryRange = chartRangeAtom("part-summary");
+export const last30PartSummary = atom((get) => {
+    const mats = get(last30MaterialSummary);
+    const cycles = get(last30StationCycles);
+    const range = get(last30PartSummaryRange);
+    const stationTimes = cycles
+        .valuesToLazySeq()
+        .filter((c) => (range.startDate === null || c.endTime >= range.startDate) &&
+        (range.endDate === null || c.endTime <= range.endDate))
+        .toLookupOrderedMap((c) => c.part, (c) => c.stationGroup, (c) => ({
+        isLoadUnload: c.isLabor,
+        elapsed: c.elapsedMinsPerMaterial * c.material.length,
+        active: c.activeMinutes,
+        medianElapsed: c.medianCycleMinutes,
+    }), (a, b) => ({
+        isLoadUnload: a.isLoadUnload || b.isLoadUnload,
+        elapsed: a.elapsed + b.elapsed,
+        active: a.active + b.active,
+        medianElapsed: a.medianElapsed + b.medianElapsed,
+    }));
+    return mats.matsById
+        .valuesToLazySeq()
+        .filter((m) => Boolean(m.numProcesses &&
+        m.unloaded_processes?.[m.numProcesses] &&
+        (range.startDate === null || m.unloaded_processes[m.numProcesses] >= range.startDate) &&
+        (range.endDate === null || m.unloaded_processes[m.numProcesses] <= range.endDate)))
+        .toOrderedLookup((m) => m.partName)
+        .mapValues((mats, partName) => ({
+        part: partName,
+        completedQty: mats.length,
+        abnormalQty: LazySeq.of(mats).sumBy((m) => (isAbnormal(m) ? 1 : 0)),
+        mats: mats,
+        stationMins: OrderedMap.empty(),
+        workorders: LazySeq.of(mats)
+            .toOrderedSet((m) => m.workorderId ?? "")
+            .delete(""),
+    }))
+        .adjust(stationTimes, (summary, stationTimes, partName) => {
+        if (summary) {
+            return { ...summary, stationMins: stationTimes };
+        }
+        else {
+            return {
+                part: partName,
+                completedQty: 0,
+                abnormalQty: 0,
+                mats: [],
+                stationMins: stationTimes,
+                workorders: OrderedSet.empty(),
+            };
+        }
+    })
+        .valuesToAscLazySeq()
+        .toRArray();
+});

package/dist/data/path-lookup.d.ts

@@ -0,0 +1,13 @@
+import { PartAndInspType, InspectionLogsByCntr } from "../cell-status/inspections.js";
+import { HashMap } from "@seedtactics/immutable-collections";
+export type PathLookupLogEntries = HashMap<PartAndInspType, InspectionLogsByCntr>;
+export interface PathLookupRange {
+    readonly part: string;
+    readonly curStart: Date;
+    readonly curEnd: Date;
+}
+export declare const pathLookupRange: import("jotai").PrimitiveAtom<PathLookupRange | null> & {
+    init: PathLookupRange | null;
+};
+export declare const inspectionLogEntries: import("jotai").Atom<PathLookupLogEntries>;
+export declare function extendRange(numDays: number): (range: PathLookupRange | null) => PathLookupRange | null;

package/dist/data/path-lookup.js

@@ -0,0 +1,107 @@
+/* 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 { LogBackend, OtherLogBackends } from "../network/backend.js";
+import { addDays } from "date-fns";
+import { convertLogToInspections, } from "../cell-status/inspections.js";
+import { HashMap, LazySeq } from "@seedtactics/immutable-collections";
+import { atom } from "jotai";
+import { loadable } from "jotai/utils";
+export const pathLookupRange = atom(null);
+const localLogEntries = atom(async (get, { signal }) => {
+    const range = get(pathLookupRange);
+    if (range == null)
+        return HashMap.empty();
+    const events = await LogBackend.get(range.curStart, range.curEnd, signal);
+    return LazySeq.of(events)
+        .flatMap(convertLogToInspections)
+        .filter((e) => e.key.part === range.part)
+        .toLookupMap((e) => e.key, (e) => e.entry.cntr, (e) => e.entry);
+});
+const localLogLoadable = loadable(localLogEntries);
+const otherLogEntries = atom(async (get) => {
+    const range = get(pathLookupRange);
+    if (range == null)
+        return HashMap.empty();
+    const allEvts = [];
+    for (const b of OtherLogBackends) {
+        allEvts.push(await b.get(range.curStart, range.curEnd));
+    }
+    return LazySeq.of(allEvts)
+        .flatMap((es) => es)
+        .flatMap(convertLogToInspections)
+        .filter((e) => e.key.part === range.part)
+        .toLookupMap((e) => e.key, (e) => e.entry.cntr, (e) => e.entry);
+});
+const otherLogLoadable = loadable(otherLogEntries);
+export const inspectionLogEntries = atom((get) => {
+    const localEvts = get(localLogLoadable);
+    const otherEvts = get(otherLogLoadable);
+    const localData = localEvts.state === "hasData" ? localEvts.data : null;
+    const otherData = otherEvts.state === "hasData" ? otherEvts.data : null;
+    if (localData) {
+        if (!otherData) {
+            return localData;
+        }
+        else {
+            return HashMap.union((inspsByCntr1, inspsByCntr2) => inspsByCntr1.union(inspsByCntr2), localData, otherData);
+        }
+    }
+    else {
+        if (otherData) {
+            return otherData;
+        }
+        else {
+            return HashMap.empty();
+        }
+    }
+});
+export function extendRange(numDays) {
+    return (range) => {
+        if (range === null)
+            return null;
+        if (numDays < 0) {
+            return {
+                curStart: addDays(range.curStart, numDays),
+                curEnd: range.curEnd,
+                part: range.part,
+            };
+        }
+        else {
+            return {
+                curStart: range.curStart,
+                curEnd: addDays(range.curEnd, numDays),
+                part: range.part,
+            };
+        }
+    };
+}

package/dist/data/queue-material.d.ts

@@ -0,0 +1,46 @@
+import * as api from "../network/api.js";
+export type SelectableJob = {
+    readonly jobUnique: string;
+    readonly job: Readonly<api.IJob> | null;
+    readonly workorder: string | null;
+    readonly machinedProcs: ReadonlyArray<{
+        readonly lastProc: number;
+        readonly details?: string;
+    }>;
+};
+export type SelectableCasting = {
+    readonly casting: string;
+    readonly message: string | null;
+};
+export type SelectableMaterialType = {
+    readonly castings: ReadonlyArray<SelectableCasting>;
+    readonly jobs: ReadonlyArray<SelectableJob>;
+};
+export declare function usePossibleNewMaterialTypes(toQueue: string | null): SelectableMaterialType;
+export interface JobRawMaterialData {
+    readonly job: Readonly<api.IActiveJob>;
+    readonly startingTime: Date | undefined;
+    readonly rawMatName: string;
+    readonly remainingToStart: number;
+    readonly assignedRaw: number;
+    readonly availableUnassigned: number;
+}
+export declare function extractJobRawMaterial(jobs: {
+    [key: string]: Readonly<api.IActiveJob>;
+}, mats: Iterable<Readonly<api.IInProcessMaterial>>, queue: string): ReadonlyArray<JobRawMaterialData>;
+export type MaterialList = ReadonlyArray<Readonly<api.IInProcessMaterial>>;
+export interface QueueRawMaterialGroup {
+    readonly partOrCasting: string;
+    readonly assignedJobUnique: string | null;
+    readonly material: MaterialList;
+}
+export interface QueueData {
+    readonly label: string;
+    readonly free: boolean;
+    readonly rawMaterialQueue: boolean;
+    readonly inProcQueue: boolean;
+    readonly material: MaterialList;
+    readonly groupedRawMat?: ReadonlyArray<QueueRawMaterialGroup>;
+}
+export declare function selectQueueData(queuesToCheck: ReadonlyArray<string>, curSt: Readonly<api.ICurrentStatus>, rawMatQueues: ReadonlySet<string>, inProcQueues: ReadonlySet<string>): ReadonlyArray<QueueData>;
+export declare function loadRawMaterialEvents(material: ReadonlyArray<Readonly<api.IInProcessMaterial>>): Promise<ReadonlyArray<Readonly<api.ILogEntry>>>;

package/dist/data/queue-material.js

@@ -0,0 +1,256 @@
+/* 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 * as api from "../network/api.js";
+import { LazySeq } from "@seedtactics/immutable-collections";
+import { LogBackend } from "../network/backend.js";
+import { differenceInSeconds } from "date-fns";
+import { useAtomValue } from "jotai";
+import { currentStatus } from "../cell-status/current-status.js";
+import { rawMaterialQueues } from "../cell-status/names.js";
+import { barcodePotentialNewMaterial } from "../cell-status/material-details.js";
+import { useMemo } from "react";
+import { last30Jobs } from "../cell-status/scheduled-jobs.js";
+function describePath(path) {
+    return `${path.palletNums && path.palletNums.length > 1
+        ? "Pallets " + path.palletNums.map((p) => p.toString()).join(",")
+        : path.palletNums && path.palletNums.length == 1
+            ? "Pallet " + path.palletNums[0].toString()
+            : "Pallet"}; ${path.stops.map((s) => s.stationGroup + "#" + (s.stationNums ?? []).join(",")).join("->")}`;
+}
+function workorderDetailForCasting(currentSt, workorderId, casting) {
+    const partNames = LazySeq.ofObject(currentSt.jobs)
+        .filter(([, j]) => j.procsAndPaths[0].paths.some((p) => p.casting === casting))
+        .toHashSet(([, j]) => j.partName);
+    const workorder = currentSt.workorders?.find((w) => w.workorderId === workorderId && (w.part === casting || partNames.has(w.part)));
+    if (!workorder)
+        return null;
+    return `Started: ${workorder.material?.length ?? 0}; Planned: ${workorder.plannedQuantity}`;
+}
+function possibleCastings(currentSt, barcode, toQueue) {
+    const workorder = barcode?.workorder;
+    return LazySeq.of(barcode?.possibleCastingsByQueue?.[toQueue] ?? [])
+        .map((c) => ({
+        casting: c,
+        message: workorder ? workorderDetailForCasting(currentSt, workorder, c) : null,
+    }))
+        .toSortedArray((c) => c.casting);
+}
+function possibleJobs(currentSt, historicJobs, barcode, toQueue) {
+    return LazySeq.of(barcode?.possibleJobsByQueue?.[toQueue] ?? [])
+        .groupBy((j) => j.jobUnique)
+        .collect(([uniq, procs]) => {
+        const job = currentSt.jobs[uniq] ?? historicJobs.get(uniq);
+        return {
+            jobUnique: uniq,
+            job: job ?? null,
+            workorder: LazySeq.of(procs)
+                .collect((p) => p.workorder)
+                .head() ?? null,
+            machinedProcs: procs.map((proc) => ({
+                lastProc: proc.lastCompletedProcess,
+                details: job?.procsAndPaths[proc.lastCompletedProcess].paths.map(describePath).join(" | ") ?? "",
+            })),
+        };
+    })
+        .toSortedArray((j) => j.job?.partName ?? j.jobUnique);
+}
+export function usePossibleNewMaterialTypes(toQueue) {
+    const historicJobs = useAtomValue(last30Jobs);
+    const currentSt = useAtomValue(currentStatus);
+    const barcode = useAtomValue(barcodePotentialNewMaterial);
+    const rawMatQueues = useAtomValue(rawMaterialQueues);
+    return useMemo(() => {
+        if (barcode === null || toQueue === null) {
+            return { castings: [], jobs: [] };
+        }
+        else {
+            return {
+                castings: rawMatQueues.has(toQueue) ? possibleCastings(currentSt, barcode, toQueue) : [],
+                jobs: possibleJobs(currentSt, historicJobs, barcode, toQueue),
+            };
+        }
+    }, [currentSt, historicJobs, toQueue, barcode, rawMatQueues]);
+}
+function isMatAssignedRaw(unique, m) {
+    return (m.jobUnique === unique &&
+        m.location.type === api.LocType.InQueue &&
+        m.action.type !== api.ActionType.Loading &&
+        m.process === 0);
+}
+function isMatUnassignedRaw(rawMatName, m) {
+    return (m.partName === rawMatName &&
+        m.location.type === api.LocType.InQueue &&
+        m.action.type !== api.ActionType.Loading &&
+        m.process === 0 &&
+        !m.jobUnique);
+}
+export function extractJobRawMaterial(jobs, mats, queue) {
+    return LazySeq.ofObject(jobs)
+        .filter(([, j]) => j.remainingToStart === undefined || j.remainingToStart > 0)
+        .collect(([, j]) => {
+        const paths = (j.procsAndPaths?.[0]?.paths ?? []).filter((p) => p.inputQueue === queue);
+        if (paths.length === 0) {
+            return null;
+        }
+        const rawMatName = LazySeq.of(paths)
+            .collect((path) => (path.casting && path.casting !== "" ? path.casting : undefined))
+            .head() ?? j.partName;
+        return {
+            job: j,
+            startingTime: LazySeq.of(paths)
+                .map((p) => p.simulatedStartingUTC)
+                .minBy((d) => d),
+            rawMatName: rawMatName,
+            remainingToStart: j.remainingToStart ?? 0,
+            assignedRaw: LazySeq.of(mats)
+                .filter((m) => isMatAssignedRaw(j.unique, m))
+                .length(),
+            availableUnassigned: LazySeq.of(mats)
+                .filter((m) => isMatUnassignedRaw(rawMatName, m))
+                .length(),
+        };
+        // })
+    })
+        .toSortedArray((x) => {
+        const prec = LazySeq.of(x.job.precedence?.[0] ?? []).minBy((p) => p);
+        if (!prec || prec < 0)
+            return Number.MAX_SAFE_INTEGER;
+        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];
+    queueNames.sort((a, b) => a.localeCompare(b));
+    for (const queueName of queueNames) {
+        const isRawMat = rawMatQueues.has(queueName);
+        if (isRawMat) {
+            const material = [];
+            const matByPartThenUniq = new Map();
+            for (const m of curSt.material) {
+                if (m.location.type === api.LocType.InQueue && m.location.currentQueue === queueName) {
+                    if ((m.serial && m.serial !== "") || m.action.type !== api.ActionType.Waiting) {
+                        material.push(m);
+                    }
+                    else {
+                        let matsForPart = matByPartThenUniq.get(m.partName);
+                        if (!matsForPart) {
+                            matsForPart = new Map();
+                            matByPartThenUniq.set(m.partName, matsForPart);
+                        }
+                        const uniq = m.jobUnique || null;
+                        const matsForJob = matsForPart.get(uniq);
+                        if (matsForJob) {
+                            matsForJob.push(m);
+                        }
+                        else {
+                            matsForPart.set(uniq, [m]);
+                        }
+                    }
+                }
+            }
+            const matGroups = [];
+            for (const [partName, matsForPart] of matByPartThenUniq) {
+                for (const [uniq, mats] of matsForPart) {
+                    matGroups.push({
+                        partOrCasting: partName,
+                        assignedJobUnique: uniq,
+                        material: mats,
+                    });
+                }
+            }
+            matGroups.sort((x, y) => {
+                const c1 = x.partOrCasting.localeCompare(y.partOrCasting);
+                if (c1 === 0) {
+                    return (x.assignedJobUnique || "").localeCompare(y.assignedJobUnique || "");
+                }
+                else {
+                    return c1;
+                }
+            });
+            queues.push({
+                label: queueName,
+                free: false,
+                rawMaterialQueue: true,
+                inProcQueue: false,
+                material: material.sort(compareByQueuePos),
+                groupedRawMat: matGroups,
+            });
+        }
+        else {
+            queues.push({
+                label: queueName,
+                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),
+            });
+        }
+    }
+    return queues;
+}
+export async function loadRawMaterialEvents(material) {
+    const events = [];
+    for (const chunk of LazySeq.of(material).chunk(15)) {
+        events.push(...(await LogBackend.logForMaterials(chunk.map((m) => m.materialID))));
+    }
+    events.sort((a, b) => a.endUTC.getTime() - b.endUTC.getTime());
+    const groupedEvents = [];
+    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];
+            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);
+                i += 1;
+            }
+            if (material.length === evt.material.length) {
+                groupedEvents.push(evt);
+            }
+            else {
+                groupedEvents.push({ ...evt, material: material });
+            }
+        }
+        else {
+            groupedEvents.push(events[i]);
+        }
+    }
+    return groupedEvents;
+}

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

@@ -0,0 +1,10 @@
+import { BufferEntry } from "../cell-status/buffers.js";
+export interface BufferChartPoint {
+    readonly x: Date;
+    readonly y: number;
+}
+export interface BufferChartSeries {
+    readonly label: string;
+    readonly points: ReadonlyArray<BufferChartPoint>;
+}
+export declare function buildBufferChart(start: Date, end: Date, movingAverageDistanceInHours: number, rawMatQueues: ReadonlySet<string>, entries: Iterable<BufferEntry>): ReadonlyArray<BufferChartSeries>;

package/dist/data/results.bufferchart.js

@@ -0,0 +1,90 @@
+/* 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 { LazySeq } from "@seedtactics/immutable-collections";
+function bufferSeriesLabel(ty) {
+    switch (ty.type) {
+        case "Queue":
+            return ty.queue;
+        case "Rotary":
+            return "Rotary " + ty.machineGroup + " #" + ty.machineNum.toString();
+        case "StockerWaitForMC":
+            return "Stocker[Waiting For Machining]";
+        case "StockerWaitForUnload":
+            return "Stocker[Waiting For Unload]";
+    }
+}
+const numPoints = 30 * 5;
+function addEntryToPoint(movingAverageDistanceInMilliseconds, point, entry) {
+    const startT = Math.max(point.x.getTime() - movingAverageDistanceInMilliseconds, entry.endTime.getTime() - entry.elapsedSeconds * 1000);
+    const endT = Math.min(point.x.getTime() + movingAverageDistanceInMilliseconds, entry.endTime.getTime());
+    point.y += ((endT - startT) / (2 * movingAverageDistanceInMilliseconds)) * entry.numMaterial;
+}
+function calcPoints(absoluteStart, absoluteEnd, movingAverageDistanceInMilliseconds, entries) {
+    // the actual start and end is inward from the start and end by the moving average distance
+    const start = new Date(absoluteStart.getTime() + movingAverageDistanceInMilliseconds);
+    const end = new Date(absoluteEnd.getTime() - movingAverageDistanceInMilliseconds);
+    const gap = (end.getTime() - start.getTime()) / (numPoints - 1);
+    const points = [];
+    // initialize all points to 0
+    for (let i = 0; i < numPoints - 1; i++) {
+        points.push({
+            x: new Date(start.getTime() + i * gap),
+            y: 0,
+        });
+    }
+    points.push({ x: end, y: 0 });
+    // add times
+    for (const e of entries) {
+        const startIdx = Math.max(0, Math.ceil((e.endTime.getTime() -
+            e.elapsedSeconds * 1000 -
+            movingAverageDistanceInMilliseconds -
+            start.getTime()) /
+            gap));
+        const endIdx = Math.min(numPoints - 1, Math.floor((e.endTime.getTime() + movingAverageDistanceInMilliseconds - start.getTime()) / gap));
+        for (let i = startIdx; i <= endIdx; i++) {
+            addEntryToPoint(movingAverageDistanceInMilliseconds, points[i], e);
+        }
+    }
+    return points;
+}
+export function buildBufferChart(start, end, movingAverageDistanceInHours, rawMatQueues, entries) {
+    const movingAverageDistanceInMilliseconds = movingAverageDistanceInHours * 60 * 60 * 1000;
+    return LazySeq.of(entries)
+        .filter((e) => e.buffer.type !== "Queue" || !rawMatQueues.has(e.buffer.queue))
+        .groupBy((v) => bufferSeriesLabel(v.buffer))
+        .map(([k, points]) => ({
+        label: k,
+        points: calcPoints(start, end, movingAverageDistanceInMilliseconds, points),
+    }))
+        .toSortedArray((a) => a.label);
+}

package/dist/data/results.completed-parts.d.ts

@@ -0,0 +1,26 @@
+import { MaterialSummaryAndCompletedData } from "../cell-status/material-summary.js";
+import { SimPartCompleted } from "../cell-status/sim-production.js";
+import { PartCycleData } from "../cell-status/station-cycles.js";
+import { HashMap } from "@seedtactics/immutable-collections";
+declare class DayAndPart {
+    day: Date;
+    part: string;
+    constructor(day: Date, part: string);
+    compare(other: DayAndPart): number;
+    hash(): number;
+    toString(): string;
+    adjustDay(f: (d: Date) => Date): DayAndPart;
+}
+export interface PartsCompletedSummary {
+    readonly count: number;
+    readonly activeMachineMins: number;
+}
+export declare function binCyclesByDayAndPart(cycles: Iterable<PartCycleData>, matsById: HashMap<number, MaterialSummaryAndCompletedData>, start: Date, end: Date): HashMap<DayAndPart, PartsCompletedSummary>;
+export declare function binSimProductionByDayAndPart(prod: Iterable<SimPartCompleted>): HashMap<DayAndPart, PartsCompletedSummary>;
+interface HeatmapClipboardPoint {
+    readonly x: Date;
+    readonly y: string;
+}
+export declare function buildCompletedPartsHeatmapTable(points: ReadonlyArray<HeatmapClipboardPoint & PartsCompletedSummary>): string;
+export declare function copyCompletedPartsHeatmapToClipboard(points: ReadonlyArray<HeatmapClipboardPoint & PartsCompletedSummary>): void;
+export {};