@seedtactics/insight-client 16.4.0

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

@@ -0,0 +1,40 @@
+import { SimStationUse } from "../cell-status/sim-station-use.js";
+import { PartCycleData } from "../cell-status/station-cycles.js";
+import { HashMap } from "@seedtactics/immutable-collections";
+export declare class DayAndStation {
+    readonly day: Date;
+    readonly station: string;
+    constructor(day: Date, station: string);
+    compare(other: DayAndStation): number;
+    hash(): number;
+    toString(): string;
+    adjustDay(f: (d: Date) => Date): DayAndStation;
+}
+export declare function binActiveCyclesByDayAndStat(cycles: Iterable<PartCycleData>): HashMap<DayAndStation, number>;
+export declare function binOccupiedCyclesByDayAndStat(cycles: Iterable<PartCycleData>): HashMap<DayAndStation, number>;
+export declare function binDowntimeToDayAndStat(simUses: Iterable<SimStationUse>): HashMap<DayAndStation, number>;
+export declare function binSimStationUseByDayAndStat(simUses: Iterable<SimStationUse>): HashMap<DayAndStation, number>;
+export interface OEEBarPoint {
+    readonly x: string;
+    readonly y: number;
+    readonly plannedHours: number;
+    readonly plannedOee: number;
+    readonly actualOee: number;
+    readonly station: string;
+    readonly day: Date;
+}
+export interface OEEBarSeries {
+    readonly station: string;
+    readonly points: ReadonlyArray<OEEBarPoint>;
+}
+export type OEEType = "labor" | "machine";
+export declare function buildOeeSeries(start: Date, end: Date, ty: OEEType, cycles: Iterable<PartCycleData>, statUse: Iterable<SimStationUse>): ReadonlyArray<OEEBarSeries>;
+export interface HeatmapClipboardPoint {
+    readonly x: Date;
+    readonly y: string;
+    readonly label: string;
+}
+export declare function buildOeeHeatmapTable(yTitle: string, points: ReadonlyArray<HeatmapClipboardPoint>): string;
+export declare function copyOeeHeatmapToClipboard(yTitle: string, points: ReadonlyArray<HeatmapClipboardPoint>): void;
+export declare function buildOeeTable(series: Iterable<OEEBarSeries>): string;
+export declare function copyOeeToClipboard(series: Iterable<OEEBarSeries>): void;

package/dist/data/results.oee.js

@@ -0,0 +1,330 @@
+/* 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 { 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 { hashValues, LazySeq } from "@seedtactics/immutable-collections";
+// --------------------------------------------------------------------------------
+// Actual
+// --------------------------------------------------------------------------------
+export class DayAndStation {
+    constructor(day, station) {
+        this.day = day;
+        this.station = station;
+    }
+    compare(other) {
+        const cmp = this.day.getTime() - other.day.getTime();
+        if (cmp !== 0)
+            return cmp;
+        return this.station.localeCompare(other.station);
+    }
+    hash() {
+        return hashValues(this.day, this.station);
+    }
+    toString() {
+        return `{day: ${this.day.toISOString()}}, station: ${this.station}}`;
+    }
+    adjustDay(f) {
+        return new DayAndStation(f(this.day), this.station);
+    }
+}
+function splitTimeToDays(startTime, endTime, mins) {
+    const startDay = startOfDay(startTime);
+    const endDay = startOfDay(endTime);
+    if (startDay.getTime() === endDay.getTime()) {
+        return [
+            {
+                day: startDay,
+                value: mins,
+            },
+        ];
+    }
+    else {
+        const vals = [];
+        const totalRange = endTime.getTime() - startTime.getTime();
+        for (let day = startDay; day <= endDay; day = addDays(day, 1)) {
+            const s = max([day, startTime]);
+            const e = min([addDays(day, 1), endTime]);
+            const pct = (e.getTime() - s.getTime()) / totalRange;
+            vals.push({
+                day,
+                value: mins * pct,
+            });
+        }
+        return vals;
+    }
+}
+function binCycles(cycles, f) {
+    return chunkCyclesWithSimilarEndTime(LazySeq.of(cycles), (c) => stat_name_and_num(c.stationGroup, c.stationNumber), (c) => c.endTime)
+        .flatMap(([statNameAndNum, cyclesForStat]) => cyclesForStat
+        .flatMap((chunk) => {
+        // 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);
+        // sum value for chunk
+        const valForChunk = LazySeq.of(chunk).sumBy((c) => f(c));
+        return splitTimeToDays(startTime, chunk[0].endTime, valForChunk);
+    })
+        .map((s) => ({
+        ...s,
+        statNameAndNum,
+    })))
+        .buildHashMap((p) => new DayAndStation(p.day, p.statNameAndNum), (old, p) => p.value + (old ?? 0));
+}
+export function binActiveCyclesByDayAndStat(cycles) {
+    return binCycles(cycles, (c) => c.activeMinutes);
+}
+export function binOccupiedCyclesByDayAndStat(cycles) {
+    return binCycles(cycles, (c) => c.elapsedMinsPerMaterial * c.material.length);
+}
+// --------------------------------------------------------------------------------
+// Planned
+// --------------------------------------------------------------------------------
+function mergeSortedIntervals(intervals) {
+    const merged = [];
+    for (const i of intervals) {
+        if (merged.length === 0) {
+            merged.push(i);
+        }
+        else {
+            const last = merged[merged.length - 1];
+            if (i.start <= last.end) {
+                merged[merged.length - 1] = {
+                    start: last.start,
+                    end: max([last.end, i.end]),
+                };
+            }
+            else {
+                merged.push(i);
+            }
+        }
+    }
+    return merged;
+}
+export function binDowntimeToDayAndStat(simUses) {
+    return LazySeq.of(simUses)
+        .filter((simUse) => simUse.plannedDown)
+        .toLookupOrderedMap((simUse) => simUse.station, (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,
+        station: station,
+    }))))
+        .toHashMap((s) => [new DayAndStation(s.day, s.station), s.value], (v1, v2) => v1 + v2);
+}
+export function binSimStationUseByDayAndStat(simUses) {
+    const downtimes = LazySeq.of(simUses)
+        .filter((simUse) => simUse.plannedDown)
+        .toLookupOrderedMap((simUse) => simUse.station, (simUse) => simUse.start)
+        .mapValues((uses) => mergeSortedIntervals(uses.valuesToAscLazySeq()));
+    return LazySeq.of(simUses)
+        .filter((simUse) => !simUse.plannedDown)
+        .toLookupOrderedMap((simUse) => simUse.station, (simUse) => simUse.start)
+        .toAscLazySeq()
+        .flatMap(([station, uses]) => {
+        const sorted = mergeSortedIntervals(uses.valuesToAscLazySeq());
+        const down = downtimes.get(station) ?? [];
+        for (let downIdx = 0, sortedIdx = 0; sortedIdx < sorted.length;) {
+            if (downIdx < down.length && down[downIdx].end <= sorted[sortedIdx].start) {
+                downIdx++;
+            }
+            else if (downIdx < down.length && down[downIdx].start < sorted[sortedIdx].end) {
+                // Downtime overlaps the interval, need to split
+                // Several cases, depending on the start and end of the intervals
+                const simStart = sorted[sortedIdx].start;
+                const simEnd = sorted[sortedIdx].end;
+                const downStart = down[downIdx].start;
+                const downEnd = down[downIdx].end;
+                if (downStart <= simStart && downEnd >= simEnd) {
+                    // down: |-----------|
+                    // sim:     |-----|
+                    // downtime removes the whole chunk
+                    sorted.splice(sortedIdx, 1);
+                    // don't increment sortedIdx, since we removed it
+                    // don't increment downIdx since a future sim might overlap
+                }
+                else if (downStart <= simStart) {
+                    // down: |-----------|
+                    // sim:     |--------------|
+                    sorted[sortedIdx] = {
+                        start: downEnd,
+                        end: simEnd,
+                    };
+                    downIdx += 1;
+                    // don't increment simIdx, since a future downtime might overlap and so still need to check
+                }
+                else if (downEnd >= simEnd) {
+                    // down:    |-----------|
+                    // sim:  |----------|
+                    sorted[sortedIdx] = {
+                        start: simStart,
+                        end: downStart,
+                    };
+                    sortedIdx += 1;
+                }
+                else {
+                    // down:    |-----------|
+                    // sim:  |---------------------|
+                    sorted[sortedIdx] = {
+                        start: simStart,
+                        end: downStart,
+                    };
+                    sorted.splice(sortedIdx + 1, 0, { start: downEnd, end: simEnd });
+                    downIdx++; // increment downIdx since we used this downtime
+                    // increment simIdx only by 1 so that we check the remaining end of the sim time
+                    // we just split
+                    sortedIdx++;
+                }
+            }
+            else {
+                // No downtimes overlapping, don't need to edit
+                sortedIdx++;
+            }
+        }
+        return sorted.flatMap((simUse) => splitTimeToDays(simUse.start, simUse.end, differenceInMinutes(simUse.end, simUse.start)).map((x) => ({
+            ...x,
+            station: station,
+        })));
+    })
+        .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 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);
+    const plannedBins = binSimStationUseByDayAndStat(filteredStatUse);
+    const series = [];
+    const statNames = actualBins
+        .keysToLazySeq()
+        .concat(plannedBins.keysToLazySeq())
+        .map((e) => e.station)
+        .distinct()
+        .toSortedArray((x) => x);
+    for (const stat of statNames) {
+        const points = [];
+        for (let d = start; d < end; d = addDays(d, 1)) {
+            const dAndStat = new DayAndStation(d, stat);
+            const actual = actualBins.get(dAndStat);
+            const planned = plannedBins.get(dAndStat);
+            const down = downtimes.get(dAndStat) ?? 0;
+            points.push({
+                x: d.toLocaleDateString(),
+                y: (actual ?? 0) / 60,
+                plannedHours: (planned ?? 0) / 60,
+                actualOee: down < 24 * 60 ? (actual ?? 0) / (24 * 60 - down) : 0,
+                plannedOee: down < 24 * 60 ? (planned ?? 0) / (24 * 60 - down) : 0,
+                station: stat,
+                day: d,
+            });
+        }
+        series.push({
+            station: stat,
+            points: points,
+        });
+    }
+    return series;
+}
+class HeatmapClipboardCell {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    compare(other) {
+        const cmp = this.x - other.x;
+        if (cmp !== 0)
+            return cmp;
+        return this.y.localeCompare(other.y);
+    }
+    hash() {
+        return hashValues(this.x, this.y);
+    }
+    toString() {
+        return `{x: ${new Date(this.x).toISOString()}, y: ${this.y}}`;
+    }
+}
+export function buildOeeHeatmapTable(yTitle, points) {
+    const cells = LazySeq.of(points).toHashMap((p) => [new HeatmapClipboardCell(p.x.getTime(), p.y), p], (_, c) => c);
+    const days = LazySeq.of(points)
+        .map((p) => p.x.getTime())
+        .distinct()
+        .toSortedArray((x) => x);
+    const rows = LazySeq.of(points)
+        .map((p) => p.y)
+        .distinct()
+        .toSortedArray((x) => x);
+    let table = "<table>\n<thead><tr><th>" + yTitle + "</th>";
+    for (const x of days) {
+        table += "<th>" + new Date(x).toDateString() + "</th>";
+    }
+    table += "</tr></thead>\n<tbody>\n";
+    for (const y of rows) {
+        table += "<tr><th>" + y + "</th>";
+        for (const x of days) {
+            const cell = cells.get(new HeatmapClipboardCell(x, y));
+            if (cell !== undefined) {
+                table += "<td>" + cell.label + "</td>";
+            }
+            else {
+                table += "<td></td>";
+            }
+        }
+        table += "</tr>\n";
+    }
+    table += "</tbody>\n</table>";
+    return table;
+}
+export function copyOeeHeatmapToClipboard(yTitle, points) {
+    copy(buildOeeHeatmapTable(yTitle, points));
+}
+export function buildOeeTable(series) {
+    let table = "<table>\n<thead><tr>";
+    table += "<th>Day</th><th>Station</th><th>Actual Hours</th><th>Planned Hours</th>";
+    table += "</tr></thead>\n<tbody>\n";
+    for (const s of series) {
+        for (const pt of s.points) {
+            table += "<tr>";
+            table += "<td>" + pt.day.toLocaleDateString() + "</td>";
+            table += "<td>" + pt.station + "</td>";
+            table += "<td>" + pt.y.toFixed(1) + "</td>";
+            table += "<td>" + pt.plannedHours.toFixed(1) + "</td>";
+            table += "</tr>\n";
+        }
+    }
+    table += "</tbody>\n</table>";
+    return table;
+}
+export function copyOeeToClipboard(series) {
+    copy(buildOeeTable(series));
+}

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

@@ -0,0 +1,23 @@
+import { MaterialSummaryAndCompletedData } from "../cell-status/material-summary.js";
+import { ICurrentStatus, IHistoricJob, IActiveJob } from "../network/api.js";
+import { HashMap } from "@seedtactics/immutable-collections";
+export interface ScheduledJobDisplay {
+    readonly partName: string;
+    readonly comment: string | null | undefined;
+    readonly routeStartTime: Date;
+    readonly historicJob: Readonly<IHistoricJob> | null;
+    readonly inProcJob: Readonly<IActiveJob> | null;
+    readonly casting: string;
+    readonly scheduledQty: number;
+    readonly decrementedQty: number;
+    readonly completedQty: number;
+    readonly inProcessQty: number;
+    readonly remainingQty: number;
+    readonly darkRow: boolean;
+}
+export declare function buildScheduledJobs(zoom: {
+    readonly start: Date;
+    readonly end: Date;
+} | undefined, matIds: HashMap<number, MaterialSummaryAndCompletedData>, schJobs: HashMap<string, Readonly<IHistoricJob>>, currentSt: Readonly<ICurrentStatus> | null): ReadonlyArray<ScheduledJobDisplay>;
+export declare function buildScheduledJobsTable(jobs: ReadonlyArray<ScheduledJobDisplay>, showMaterial: boolean): string;
+export declare function copyScheduledJobsToClipboard(jobs: ReadonlyArray<ScheduledJobDisplay>, showMaterial: boolean): void;

package/dist/data/results.schedules.js

@@ -0,0 +1,157 @@
+/* Copyright (c) 2022, John Lenz
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of John Lenz, Black Maple Software, SeedTactics,
+      nor the names of other contributors may be used to endorse or
+      promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import copy from "copy-to-clipboard";
+import { LazySeq } from "@seedtactics/immutable-collections";
+export function buildScheduledJobs(zoom, matIds, schJobs, currentSt) {
+    const completedMats = LazySeq.of(matIds)
+        .flatMap(([matId, summary]) => LazySeq.ofObject(summary.unloaded_processes ?? {}).map(([proc, _]) => ({
+        matId: matId,
+        proc: parseInt(proc),
+        uniq: summary.jobUnique,
+    })))
+        .toLookupMap((m) => m.uniq, (m) => m.proc, () => 1, (a, b) => a + b);
+    const result = new Map();
+    if (currentSt) {
+        for (const [uniq, curJob] of LazySeq.ofObject(currentSt.jobs)) {
+            const casting = LazySeq.of(curJob.procsAndPaths[0]?.paths ?? [])
+                .collect((p) => (p.casting === "" ? null : p.casting))
+                .head();
+            result.set(uniq, {
+                partName: curJob.partName,
+                comment: curJob.comment,
+                routeStartTime: curJob.routeStartUTC,
+                historicJob: null,
+                inProcJob: curJob,
+                casting: casting ?? "",
+                scheduledQty: curJob.cycles ?? 0,
+                decrementedQty: LazySeq.of(curJob.decrements || []).sumBy((d) => d.quantity),
+                completedQty: LazySeq.of(curJob.completed?.[curJob.completed?.length - 1] ?? []).sumBy((c) => c),
+                inProcessQty: 0,
+                remainingQty: curJob.remainingToStart ?? 0,
+                darkRow: false,
+            });
+        }
+    }
+    for (const [uniq, schJob] of schJobs) {
+        const displayJob = result.get(uniq);
+        if (displayJob) {
+            displayJob.historicJob = schJob;
+        }
+        else {
+            if (!zoom || (schJob.routeStartUTC >= zoom.start && schJob.routeStartUTC <= zoom.end)) {
+                const casting = LazySeq.of(schJob.procsAndPaths[0]?.paths ?? [])
+                    .collect((p) => (p.casting === "" ? null : p.casting))
+                    .head();
+                result.set(uniq, {
+                    partName: schJob.partName,
+                    comment: schJob.comment,
+                    routeStartTime: schJob.routeStartUTC,
+                    historicJob: schJob,
+                    inProcJob: null,
+                    casting: casting ?? "",
+                    scheduledQty: schJob.cycles ?? 0,
+                    decrementedQty: LazySeq.of(schJob.decrements || []).sumBy((d) => d.quantity),
+                    completedQty: completedMats.get(uniq)?.get(schJob.procsAndPaths.length) ?? 0,
+                    inProcessQty: 0,
+                    darkRow: false,
+                    remainingQty: 0,
+                });
+            }
+        }
+    }
+    if (currentSt) {
+        for (const mat of currentSt.material) {
+            if (mat.jobUnique) {
+                const job = result.get(mat.jobUnique);
+                if (job) {
+                    job.inProcessQty += 1;
+                }
+            }
+        }
+    }
+    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;
+        }
+    });
+    let lastSchId = null;
+    let curDark = true;
+    for (const job of sorted) {
+        if (lastSchId != (job.historicJob?.scheduleId ?? job.inProcJob?.scheduleId ?? null)) {
+            curDark = !curDark;
+            lastSchId = job.historicJob?.scheduleId ?? job.inProcJob?.scheduleId ?? null;
+        }
+        job.darkRow = curDark;
+    }
+    return sorted;
+}
+// --------------------------------------------------------------------------------
+// Clipboard
+// --------------------------------------------------------------------------------
+export function buildScheduledJobsTable(jobs, showMaterial) {
+    let table = "<table>\n<thead><tr>";
+    table += "<th>Date</th>";
+    table += "<th>Part</th>";
+    if (showMaterial) {
+        table += "<th>Material</th>";
+    }
+    table += "<th>Note</th>";
+    table += "<th>Scheduled</th>";
+    table += "<th>Removed</th>";
+    table += "<th>Completed</th>";
+    table += "<th>In Process</th>";
+    table += "</tr></thead>\n<tbody>\n";
+    for (const s of jobs) {
+        table += "<tr><td>" + s.routeStartTime.toString() + "</td>";
+        table += "<td>" + s.partName + "</td>";
+        if (showMaterial) {
+            table += "<td>" + (s.casting ?? s.partName) + "</td>";
+        }
+        table += "<td>" + (s.comment ?? "") + "</td>";
+        table += "<td>" + s.scheduledQty.toFixed(0) + "</td>";
+        table += "<td>" + s.decrementedQty.toFixed(0) + "</td>";
+        table += "<td>" + s.completedQty.toFixed(0) + "</td>";
+        table += "<td>" + s.inProcessQty.toFixed(0) + "</td>";
+        table += "</tr>\n";
+    }
+    table += "</tbody>\n</table>";
+    return table;
+}
+export function copyScheduledJobsToClipboard(jobs, showMaterial) {
+    copy(buildScheduledJobsTable(jobs, showMaterial));
+}

package/dist/data/tools-programs.d.ts

@@ -0,0 +1,78 @@
+import { ICurrentStatus, IHistoricJob, IProgramInCellController, IToolInMachine } from "../network/api.js";
+import { ProgramToolUseInSingleCycle, ToolUsage } from "../cell-status/tool-usage.js";
+import { EstimatedCycleTimes, PartAndStationOperation, StatisticalCycleTime } from "../cell-status/estimated-cycle-times.js";
+import { HashMap, OrderedSet } from "@seedtactics/immutable-collections";
+export type ToolInMachine = {
+    readonly machineName: string;
+    readonly pocket: number;
+    readonly serial?: string;
+    readonly currentUseMinutes: number | null;
+    readonly lifetimeMinutes: number | null;
+    readonly remainingMinutes: number | null;
+    readonly currentUseCnt: number | null;
+    readonly lifetimeCnt: number | null;
+    readonly remainingCnt: number | null;
+};
+export type PartToolUsage = {
+    readonly partAndProg: PartAndStationOperation;
+    readonly quantity: number;
+    readonly scheduledUseMinutes: number;
+    readonly scheduledUseCnt: number;
+    readonly machines: OrderedSet<string>;
+};
+export type ToolReport = {
+    readonly toolName: string;
+    readonly machines: ReadonlyArray<ToolInMachine>;
+    readonly parts: ReadonlyArray<PartToolUsage>;
+    readonly estimatedToolCounts: boolean;
+};
+declare global {
+    interface Window {
+        bmsToolReportOverridePartQuantity?: number;
+    }
+}
+export declare function calcToolReport(currentSt: Readonly<ICurrentStatus>, toolsInMach: ReadonlyArray<Readonly<IToolInMachine>>, usage: ToolUsage): ReadonlyArray<ToolReport>;
+export declare const toolReportRefreshTime: import("jotai").WritableAtom<Date | null, [Date], Promise<void>>;
+export declare const machinesWithTools: import("jotai").Atom<readonly string[]>;
+export declare const currentToolReport: import("jotai").Atom<readonly ToolReport[] | null>;
+export declare const toolReportHasSerial: import("jotai").Atom<boolean>;
+export declare const toolReportEstimatedToolCounts: import("jotai").Atom<boolean>;
+export declare function useCopyToolReportToClipboard(): () => void;
+export interface CellControllerProgram {
+    readonly programName: string;
+    readonly cellControllerProgramName: string;
+    readonly comment: string | null;
+    readonly revision: number | null;
+    readonly partName: string | null;
+    readonly statisticalCycleTime: StatisticalCycleTime | null;
+    readonly toolUse: ProgramToolUseInSingleCycle | null;
+    readonly plannedMins: number | null;
+}
+export interface ProgramReport {
+    readonly time: Date;
+    readonly programs: ReadonlyArray<CellControllerProgram>;
+    readonly hasRevisions: boolean;
+    readonly cellNameDifferentFromProgName: boolean;
+}
+export declare function calcProgramReport(usage: ToolUsage, cycleTimes: EstimatedCycleTimes, jobs: HashMap<string, Readonly<IHistoricJob>> | null, progsInCellCtrl: ReadonlyArray<Readonly<IProgramInCellController>>, progsToShow: ReadonlySet<string> | null): ProgramReport;
+export declare const programFilter: import("jotai").PrimitiveAtom<"AllPrograms" | "ActivePrograms"> & {
+    init: "AllPrograms" | "ActivePrograms";
+};
+export declare const programReportRefreshTime: import("jotai").WritableAtom<Date | null, [Date], Promise<void>>;
+export declare const currentProgramReport: import("jotai").Atom<ProgramReport | null>;
+export type ProgramNameAndRevision = {
+    readonly programName: string;
+    readonly revision: number | null;
+    readonly partName: string | null;
+};
+export declare const programToShowContent: import("jotai").PrimitiveAtom<ProgramNameAndRevision | null> & {
+    init: ProgramNameAndRevision | null;
+};
+export declare const programContent: import("jotai").Atom<Promise<string>>;
+export type ProgramHistoryRequest = {
+    readonly programName: string;
+    readonly partName: string | null;
+};
+export declare const programToShowHistory: import("jotai").PrimitiveAtom<ProgramHistoryRequest | null> & {
+    init: ProgramHistoryRequest | null;
+};