@seedtactics/insight-client 16.4.0

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

@@ -0,0 +1,181 @@
+/* Copyright (c) 2021, 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 } from "date-fns";
+import copy from "copy-to-clipboard";
+import { hashValues, LazySeq } from "@seedtactics/immutable-collections";
+// --------------------------------------------------------------------------------
+// Actual
+// --------------------------------------------------------------------------------
+class DayAndPart {
+    constructor(day, part) {
+        this.day = day;
+        this.part = part;
+    }
+    compare(other) {
+        const cmp = this.day.getTime() - other.day.getTime();
+        if (cmp === 0) {
+            return this.part.localeCompare(other.part);
+        }
+        else {
+            return cmp;
+        }
+    }
+    hash() {
+        return hashValues(this.day, this.part);
+    }
+    toString() {
+        return `{day: ${this.day.toISOString()}}, part: ${this.part}}`;
+    }
+    adjustDay(f) {
+        return new DayAndPart(f(this.day), this.part);
+    }
+}
+class MatIdAndProcess {
+    constructor(matId, proc) {
+        this.matId = matId;
+        this.proc = proc;
+    }
+    compare(other) {
+        const cmp = this.matId - other.matId;
+        if (cmp === 0) {
+            return this.proc - other.proc;
+        }
+        else {
+            return cmp;
+        }
+    }
+    hash() {
+        return hashValues(this.matId, this.proc);
+    }
+    toString() {
+        return this.matId.toString() + "-" + this.proc.toString();
+    }
+}
+export function binCyclesByDayAndPart(cycles, matsById, start, end) {
+    const activeTimeByMatId = LazySeq.of(cycles)
+        .filter((cycle) => cycle.endTime >= start &&
+        cycle.endTime <= end &&
+        !cycle.isLabor &&
+        cycle.activeMinutes > 0 &&
+        cycle.material.length > 0)
+        .flatMap((cycle) => cycle.material.map((mat) => ({
+        matId: mat.id,
+        proc: mat.proc,
+        active: cycle.activeMinutes / cycle.material.length,
+    })))
+        .toHashMap((p) => [new MatIdAndProcess(p.matId, p.proc), p.active], (a1, a2) => a1 + a2);
+    return LazySeq.of(matsById)
+        .flatMap(([matId, details]) => LazySeq.ofObject(details.unloaded_processes ?? {})
+        .filter(([_, unloadTime]) => unloadTime >= start && unloadTime <= end)
+        .map(([proc, unloadTime]) => ({
+        day: startOfDay(unloadTime),
+        part: details.partName + "-" + proc.toString(),
+        value: {
+            count: 1,
+            activeMachineMins: activeTimeByMatId.get(new MatIdAndProcess(matId, parseInt(proc))) ?? 0,
+        },
+    })))
+        .toHashMap((p) => [new DayAndPart(p.day, p.part), p.value], (v1, v2) => ({
+        count: v1.count + v2.count,
+        activeMachineMins: v1.activeMachineMins + v2.activeMachineMins,
+    }));
+}
+// --------------------------------------------------------------------------------
+// Planned
+// --------------------------------------------------------------------------------
+export function binSimProductionByDayAndPart(prod) {
+    return LazySeq.of(prod).toHashMap((p) => [
+        new DayAndPart(startOfDay(p.completeTime), p.partName + "-" + p.process.toString()),
+        { count: p.quantity, activeMachineMins: p.expectedMachineMins },
+    ], (v1, v2) => ({
+        count: v1.count + v2.count,
+        activeMachineMins: v1.activeMachineMins + v2.activeMachineMins,
+    }));
+}
+class HeatmapClipboardCell {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    compare(other) {
+        const cmp = this.x - other.x;
+        if (cmp === 0) {
+            return this.y.localeCompare(other.y);
+        }
+        else {
+            return cmp;
+        }
+    }
+    hash() {
+        return hashValues(this.x, this.y);
+    }
+    toString() {
+        return `{x: ${new Date(this.x).toISOString()}, y: ${this.y}}`;
+    }
+}
+export function buildCompletedPartsHeatmapTable(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)
+        .aggregate((p) => p.y, (p) => p.activeMachineMins / p.count, (first, snd) => (isNaN(first) ? snd : first))
+        .sortBy(([name, _cycleMins]) => name);
+    let table = "<table>\n<thead><tr><th>Part</th><th>Expected Cycle Mins</th>";
+    for (const x of days) {
+        table += "<th>" + new Date(x).toDateString() + " Completed</th>";
+        table += "<th>" + new Date(x).toDateString() + " Std. Hours</th>";
+    }
+    table += "</tr></thead>\n<tbody>\n";
+    for (const [partName, cycleMins] of rows) {
+        table += "<tr><th>" + partName + "</th><th>" + cycleMins.toFixed(1) + "</th>";
+        for (const x of days) {
+            const cell = cells.get(new HeatmapClipboardCell(x, partName));
+            if (cell !== undefined) {
+                table += "<td>" + cell.count.toFixed(0) + "</td>";
+                table += "<td>" + (cell.activeMachineMins / 60).toFixed(1) + "</td>";
+            }
+            else {
+                table += "<td></td>";
+                table += "<td></td>";
+            }
+        }
+        table += "</tr>\n";
+    }
+    table += "</tbody>\n</table>";
+    return table;
+}
+export function copyCompletedPartsHeatmapToClipboard(points) {
+    copy(buildCompletedPartsHeatmapTable(points));
+}

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

@@ -0,0 +1,86 @@
+import * as api from "../network/api.js";
+import { MaterialSummaryAndCompletedData } from "../cell-status/material-summary.js";
+import { PartAndStationOperation } from "../cell-status/estimated-cycle-times.js";
+import { PartCycleData } from "../cell-status/station-cycles.js";
+import { PalletCyclesByPallet } from "../cell-status/pallet-cycles.js";
+import { HashMap, LazySeq } from "@seedtactics/immutable-collections";
+export interface PartAndProcess {
+    readonly part: string;
+    readonly proc: number;
+}
+export interface CycleFilterOptions {
+    readonly allPartAndProcNames: ReadonlyArray<PartAndProcess>;
+    readonly allPalletNames: ReadonlyArray<number>;
+    readonly allLoadStationNames: ReadonlyArray<string>;
+    readonly allMachineNames: ReadonlyArray<string>;
+    readonly allMachineOperations: ReadonlyArray<PartAndStationOperation>;
+}
+export type PartCycleChartData = PartCycleData & {
+    readonly x: Date;
+    readonly y: number;
+};
+export interface FilteredStationCycles {
+    readonly seriesLabel: string;
+    readonly data: ReadonlyMap<string, ReadonlyArray<PartCycleChartData>>;
+}
+export declare const FilterAnyMachineKey = "@@@_FMSInsight_FilterAnyMachineKey_@@@";
+export declare const FilterAnyLoadKey = "@@@_FMSInsigt_FilterAnyLoadKey_@@@";
+export interface StationCycleFilter {
+    readonly zoom?: {
+        start: Date;
+        end: Date;
+    };
+    readonly partAndProc?: PartAndProcess;
+    readonly pallet?: number;
+    readonly station?: string;
+    readonly operation?: PartAndStationOperation;
+}
+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 interface LoadCycleData extends PartCycleChartData {
+    readonly operations?: ReadonlyArray<{
+        readonly mat: Readonly<api.ILogMaterial>;
+        readonly operation: string;
+    }>;
+}
+export interface FilteredLoadCycles {
+    readonly seriesLabel: string;
+    readonly data: ReadonlyMap<string, ReadonlyArray<LoadCycleData>>;
+}
+export interface LoadCycleFilter {
+    readonly zoom?: {
+        start: Date;
+        end: Date;
+    };
+    readonly partAndProc?: PartAndProcess;
+    readonly pallet?: number;
+    readonly station?: string;
+}
+export declare function loadOccupancyCycles(allCycles: Iterable<PartCycleData>, { zoom, partAndProc, pallet, station }: LoadCycleFilter): FilteredLoadCycles & CycleFilterOptions;
+export declare function plannedOperationMinutes(s: FilteredStationCycles, forSingleMat: boolean): number | undefined;
+export interface RecentCycle {
+    readonly station: string;
+    readonly startTime: Date;
+    readonly endOccupied: Date;
+    readonly endActive?: Date;
+    readonly outlier: boolean;
+    readonly parts: ReadonlyArray<{
+        part: string;
+        oper: string;
+    }>;
+}
+export declare function recentCycles(allCycles: LazySeq<PartCycleData>): ReadonlyArray<RecentCycle>;
+export declare function format_cycle_inspection(c: PartCycleData, matsById: HashMap<number, MaterialSummaryAndCompletedData>): string;
+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 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;
+export declare function buildLogEntriesTable(cycles: Iterable<Readonly<api.ILogEntry>>): string;
+export declare function copyLogEntriesToClipboard(cycles: Iterable<Readonly<api.ILogEntry>>): void;