@seedtactics/insight-client 16.4.0

package/dist/data/current-cycles.js

@@ -0,0 +1,144 @@
+/* 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 { LazySeq } from "@seedtactics/immutable-collections";
+import { addSeconds } from "date-fns";
+import { isOutlierAbove, PartAndStationOperation, splitElapsedTimeAmongChunk, } from "../cell-status/estimated-cycle-times.js";
+import { stat_name_and_num } from "../cell-status/station-cycles.js";
+import { ActionType } from "../network/api.js";
+import { durationToMinutes, durationToSeconds } from "../util/parseISODuration.js";
+function machiningCurrentCycles(currentSt, estimated, palToLoc) {
+    return LazySeq.of(currentSt.material)
+        .collect((m) => {
+        if (m.action.type !== ActionType.Machining)
+            return null;
+        if (!m.location.palletNum)
+            return null;
+        const loc = palToLoc.get(m.location.palletNum);
+        if (!loc)
+            return null;
+        return { mat: m, loc };
+    })
+        .groupBy(({ loc }) => loc.group, ({ loc }) => loc.num)
+        .map(([[statGroup, statNum], mats]) => {
+        // all mats currently machining at the same station should all have the same part and program
+        const stats = estimated.get(new PartAndStationOperation(mats[0].mat.partName, statGroup, mats[0].mat.action.program ?? ""));
+        const elapsedSec = durationToSeconds(mats[0].mat.action.elapsedMachiningTime ?? "PT0S");
+        const remainingSec = durationToSeconds(mats[0].mat.action.expectedRemainingMachiningTime ?? "PT0S");
+        return {
+            station: stat_name_and_num(statGroup, statNum),
+            start: addSeconds(currentSt.timeOfCurrentStatusUTC, -elapsedSec),
+            expectedEnd: addSeconds(currentSt.timeOfCurrentStatusUTC, remainingSec),
+            isOutlier: stats ? isOutlierAbove(stats, elapsedSec / 60 / mats.length) : false,
+            parts: [{ part: mats[0].mat.partName, oper: mats[0].mat.action.program ?? "" }],
+        };
+    });
+}
+function loadCurrentCycles(currentSt, estimated, palToLoc) {
+    return LazySeq.of(currentSt.material)
+        .collect((m) => {
+        if (m.action.type === ActionType.UnloadToCompletedMaterial ||
+            m.action.type === ActionType.UnloadToInProcess) {
+            if (!m.location.palletNum)
+                return null;
+            const loc = palToLoc.get(m.location.palletNum);
+            if (!loc)
+                return null;
+            return { mat: m, material: [m], proc: m.process, path: m.path, loc };
+        }
+        else if (m.action.type === ActionType.Loading) {
+            if (!m.action.loadOntoPalletNum)
+                return null;
+            const loc = palToLoc.get(m.action.loadOntoPalletNum);
+            if (!loc)
+                return null;
+            return {
+                mat: m,
+                material: [m],
+                proc: m.action.processAfterLoad ?? m.process,
+                path: m.action.pathAfterLoad ?? m.path,
+                loc,
+            };
+        }
+        return null;
+    })
+        .map((m) => {
+        const job = currentSt.jobs[m.mat.jobUnique];
+        const pathData = job?.procsAndPaths?.[m.proc - 1]?.paths?.[m.path - 1];
+        if (m.mat.action.type === ActionType.Loading) {
+            return { ...m, expectedLoadSecs: durationToSeconds(pathData?.expectedLoadTime ?? "PT0S") };
+        }
+        else {
+            return { ...m, expectedLoadSecs: durationToSeconds(pathData?.expectedUnloadTime ?? "PT0S") };
+        }
+    })
+        .groupBy(({ loc }) => loc.group, ({ loc }) => loc.num)
+        .map(([[statGroup, statNum], mats]) => {
+        const matsWithTime = splitElapsedTimeAmongChunk(mats, (m) => durationToMinutes(m.mat.action.elapsedLoadUnloadTime ?? "PT0S"), (m) => m.expectedLoadSecs / 60);
+        let outlier = false;
+        let expectedSecs = 0;
+        for (const { cycle: m, elapsedForSingleMaterialMinutes } of matsWithTime) {
+            const stats = estimated.get(new PartAndStationOperation(m.mat.partName, statGroup, m.mat.action.type === ActionType.Loading
+                ? "LOAD-" + m.proc.toString()
+                : "UNLOAD-" + m.proc.toString()));
+            if (stats && isOutlierAbove(stats, elapsedForSingleMaterialMinutes)) {
+                outlier = true;
+            }
+            if (m.expectedLoadSecs > 0) {
+                expectedSecs += m.expectedLoadSecs;
+            }
+            else if (stats?.expectedCycleMinutesForSingleMat) {
+                expectedSecs += stats.expectedCycleMinutesForSingleMat * 60;
+            }
+        }
+        const elapsedSec = durationToSeconds(mats[0].mat.action.elapsedLoadUnloadTime ?? "PT0S");
+        return {
+            station: stat_name_and_num(statGroup, statNum),
+            start: addSeconds(currentSt.timeOfCurrentStatusUTC, -elapsedSec),
+            expectedEnd: addSeconds(currentSt.timeOfCurrentStatusUTC, -elapsedSec + expectedSecs),
+            isOutlier: outlier,
+            parts: LazySeq.of(mats)
+                .distinctAndSortBy((m) => m.mat.partName, (m) => m.proc, (m) => (m.mat.action.type === ActionType.Loading ? "LOAD" : "UNLOAD"))
+                .map((m) => ({
+                part: m.mat.partName + "-" + m.proc.toString(),
+                oper: m.mat.action.type === ActionType.Loading ? "LOAD" : "UNLOAD",
+            }))
+                .toRArray(),
+        };
+    });
+}
+export function currentCycles(currentSt, estimated) {
+    const palToLoc = LazySeq.ofObject(currentSt.pallets).buildHashMap(([, p]) => p.palletNum, (_old, [, pal]) => pal.currentPalletLocation);
+    return machiningCurrentCycles(currentSt, estimated, palToLoc)
+        .concat(loadCurrentCycles(currentSt, estimated, palToLoc))
+        .toRArray();
+}

package/dist/data/inspection-sankey.d.ts

@@ -0,0 +1,15 @@
+import { InspectionLogEntry } from "../cell-status/inspections.js";
+export interface SankeyNode {
+    readonly unique: string;
+    readonly name: string;
+}
+export interface SankeyLink {
+    readonly source: number;
+    readonly target: number;
+    readonly value: number;
+}
+export interface SankeyDiagram {
+    readonly nodes: Array<SankeyNode>;
+    readonly links: Array<SankeyLink>;
+}
+export declare function inspectionDataToSankey(d: Iterable<InspectionLogEntry>): SankeyDiagram;

package/dist/data/inspection-sankey.js

@@ -0,0 +1,147 @@
+/* Copyright (c) 2018, 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 { InspectionLogResultType } from "../cell-status/inspections.js";
+import { hashValues, LazySeq } from "@seedtactics/immutable-collections";
+class NodeR {
+    constructor(unique, name) {
+        this.unique = unique;
+        this.name = name;
+    }
+    compare(other) {
+        const cmp = this.unique.localeCompare(other.unique);
+        if (cmp === 0) {
+            return this.name.localeCompare(other.name);
+        }
+        else {
+            return cmp;
+        }
+    }
+    hash() {
+        return hashValues(this.unique, this.name);
+    }
+    toString() {
+        return `{unique: ${this.unique}}, name: ${this.name}}`;
+    }
+}
+class Edge {
+    constructor(from, to) {
+        this.from = from;
+        this.to = to;
+    }
+    compare(other) {
+        const cmp = this.from.compare(other.from);
+        if (cmp === 0) {
+            return this.to.compare(other.to);
+        }
+        else {
+            return cmp;
+        }
+    }
+    hash() {
+        return hashValues(this.from, this.to);
+    }
+    toString() {
+        return `{from: ${this.from.toString()}}, to: ${this.to.toString()}}`;
+    }
+}
+function edgesForPath(actualPath, toInspect, result) {
+    let path = "";
+    let prevNode = new NodeR("", "raw");
+    const edges = [];
+    for (const proc of actualPath) {
+        for (const stop of proc.stops) {
+            const cur = "P" + proc.pallet + ",M" + stop.stationNum.toString();
+            path += "->" + cur;
+            const nextNode = new NodeR(path, cur);
+            edges.push(new Edge(prevNode, nextNode));
+            prevNode = nextNode;
+        }
+    }
+    if (toInspect && result !== undefined) {
+        if (result) {
+            edges.push(new Edge(prevNode, new NodeR("@@success", "success")));
+        }
+        else {
+            edges.push(new Edge(prevNode, new NodeR("@@failed", "failed")));
+        }
+    }
+    else {
+        edges.push(new Edge(prevNode, new NodeR("@@uninspected", "uninspected")));
+    }
+    return edges;
+}
+export function inspectionDataToSankey(d) {
+    const matIdToInspResult = LazySeq.of(d)
+        .filter((e) => e.result.type === InspectionLogResultType.Completed)
+        .toRMap((e) => [
+        e.materialID,
+        e.result.type === InspectionLogResultType.Completed ? e.result.success : false,
+    ]);
+    // create all the edges, likely with duplicate edges between nodes
+    const edges = LazySeq.of(d).flatMap((c) => {
+        if (c.result.type === InspectionLogResultType.Triggered) {
+            return edgesForPath(c.result.actualPath, c.result.toInspect, matIdToInspResult.get(c.materialID) ?? false);
+        }
+        else {
+            return [];
+        }
+    });
+    // extract the nodes and assign an index
+    const nodes = edges
+        .flatMap((e) => [e.from, e.to])
+        .distinctBy((x) => x)
+        .map((node, idx) => ({ idx, node }));
+    // create the sankey nodes to return
+    const sankeyNodes = nodes
+        .map((s) => ({
+        unique: s.node.unique,
+        name: s.node.name,
+    }))
+        .toMutableArray();
+    // create a map from NodeR to index
+    const nodesToIdx = nodes.toHashMap((n) => [n.node, n.idx], (i1, _) => i1);
+    // create the sankey links to return by counting Edges between nodes
+    const sankeyLinks = edges
+        .toHashMap((e) => [e, 1], (c1, c2) => c1 + c2)
+        .toLazySeq()
+        .map(([link, value]) => ({
+        source: nodesToIdx.get(link.from),
+        target: nodesToIdx.get(link.to),
+        value,
+    }))
+        .toMutableArray();
+    return {
+        nodes: sankeyNodes,
+        links: sankeyLinks,
+    };
+}

package/dist/data/move-arrows.d.ts

@@ -0,0 +1,48 @@
+import * as api from "../network/api.js";
+import { HashMap } from "@seedtactics/immutable-collections";
+export declare enum MoveMaterialNodeKindType {
+    Material = 0,
+    FreeMaterialZone = 1,
+    CompletedCollapsedMaterialZone = 2,
+    CompletedExpandedMaterialZone = 3,
+    PalletFaceZone = 4,
+    QueueZone = 5
+}
+export type MoveMaterialNodeKind = {
+    readonly type: MoveMaterialNodeKindType.Material;
+    readonly material: Readonly<api.IInProcessMaterial> | null;
+} | {
+    readonly type: MoveMaterialNodeKindType.FreeMaterialZone;
+} | {
+    readonly type: MoveMaterialNodeKindType.CompletedCollapsedMaterialZone;
+} | {
+    readonly type: MoveMaterialNodeKindType.CompletedExpandedMaterialZone;
+} | {
+    readonly type: MoveMaterialNodeKindType.PalletFaceZone;
+    readonly face: number;
+} | {
+    readonly type: MoveMaterialNodeKindType.QueueZone;
+    readonly queue: string;
+};
+export type MoveMaterialIdentifier = string;
+export declare function uniqueIdForNodeKind(kind: MoveMaterialNodeKind): MoveMaterialIdentifier;
+export declare function memoPropsForNodeKind(kind: MoveMaterialNodeKind): ReadonlyArray<unknown>;
+export type AllMoveMaterialNodes<T> = HashMap<MoveMaterialIdentifier, MoveMaterialNodeKind & {
+    readonly elem: T;
+}>;
+export type MoveMaterialArrow = {
+    readonly fromX: number;
+    readonly fromY: number;
+    readonly toX: number;
+    readonly toY: number;
+    readonly curveDirection: number;
+};
+export type MoveMaterialElemRect = {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+    readonly bottom: number;
+    readonly right: number;
+};
+export declare function computeArrows(container: MoveMaterialElemRect | null | undefined, allNodes: AllMoveMaterialNodes<MoveMaterialElemRect>): ReadonlyArray<MoveMaterialArrow>;

package/dist/data/move-arrows.js

@@ -0,0 +1,217 @@
+/* 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 * as api from "../network/api.js";
+import { LazySeq } from "@seedtactics/immutable-collections";
+export var MoveMaterialNodeKindType;
+(function (MoveMaterialNodeKindType) {
+    MoveMaterialNodeKindType[MoveMaterialNodeKindType["Material"] = 0] = "Material";
+    MoveMaterialNodeKindType[MoveMaterialNodeKindType["FreeMaterialZone"] = 1] = "FreeMaterialZone";
+    MoveMaterialNodeKindType[MoveMaterialNodeKindType["CompletedCollapsedMaterialZone"] = 2] = "CompletedCollapsedMaterialZone";
+    MoveMaterialNodeKindType[MoveMaterialNodeKindType["CompletedExpandedMaterialZone"] = 3] = "CompletedExpandedMaterialZone";
+    MoveMaterialNodeKindType[MoveMaterialNodeKindType["PalletFaceZone"] = 4] = "PalletFaceZone";
+    MoveMaterialNodeKindType[MoveMaterialNodeKindType["QueueZone"] = 5] = "QueueZone";
+})(MoveMaterialNodeKindType || (MoveMaterialNodeKindType = {}));
+export function uniqueIdForNodeKind(kind) {
+    switch (kind.type) {
+        case MoveMaterialNodeKindType.Material:
+            return "Material-" + (kind.material?.materialID ?? -1).toString();
+        case MoveMaterialNodeKindType.FreeMaterialZone:
+            return "FreeMaterialZone";
+        case MoveMaterialNodeKindType.CompletedCollapsedMaterialZone:
+            return "CompletedCollapsedMaterialZone";
+        case MoveMaterialNodeKindType.CompletedExpandedMaterialZone:
+            return "CompletedExpandedMaterialZone";
+        case MoveMaterialNodeKindType.PalletFaceZone:
+            return "PalletFaceZone-" + kind.face.toString();
+        case MoveMaterialNodeKindType.QueueZone:
+            return "QueueZone-" + kind.queue;
+    }
+}
+export function memoPropsForNodeKind(kind) {
+    switch (kind.type) {
+        case MoveMaterialNodeKindType.Material:
+            return [kind.type, kind.material];
+        case MoveMaterialNodeKindType.FreeMaterialZone:
+        case MoveMaterialNodeKindType.CompletedCollapsedMaterialZone:
+        case MoveMaterialNodeKindType.CompletedExpandedMaterialZone:
+            return [kind.type, null];
+        case MoveMaterialNodeKindType.PalletFaceZone:
+            return [kind.type, kind.face];
+        case MoveMaterialNodeKindType.QueueZone:
+            return [kind.type, kind.queue];
+    }
+}
+function groupMatByKind(allNodes) {
+    let freeMaterial;
+    let completedMaterial;
+    const faces = new Map();
+    const queues = new Map();
+    const material = new Array();
+    for (const node of allNodes.values()) {
+        switch (node.type) {
+            case MoveMaterialNodeKindType.FreeMaterialZone:
+                freeMaterial = node.elem;
+                break;
+            case MoveMaterialNodeKindType.CompletedCollapsedMaterialZone:
+            case MoveMaterialNodeKindType.CompletedExpandedMaterialZone:
+                completedMaterial = node.elem;
+                break;
+            case MoveMaterialNodeKindType.PalletFaceZone:
+                faces.set(node.face, node.elem);
+                break;
+            case MoveMaterialNodeKindType.QueueZone:
+                queues.set(node.queue, node.elem);
+                break;
+            case MoveMaterialNodeKindType.Material:
+                if (node.material) {
+                    material.push([node.elem, node.material]);
+                }
+                break;
+        }
+    }
+    return { freeMaterial, completedMaterial, faces, queues, material };
+}
+export function computeArrows(container, allNodes) {
+    if (!container) {
+        return [];
+    }
+    const byKind = groupMatByKind(allNodes);
+    if (!byKind.completedMaterial) {
+        return [];
+    }
+    const arrows = [];
+    const faceDestUsed = new Map();
+    const queueDestUsed = new Map();
+    let lastFreeUsed = 0;
+    for (const [rect, mat] of LazySeq.of(byKind.material).sortBy(([rect]) => rect.left, ([rect]) => rect.top)) {
+        switch (mat.action.type) {
+            case api.ActionType.UnloadToCompletedMaterial:
+            case api.ActionType.UnloadToInProcess:
+                if (mat.action.type === api.ActionType.UnloadToCompletedMaterial &&
+                    (!mat.action.unloadIntoQueue || mat.action.unloadIntoQueue === "")) {
+                    arrows.push({
+                        fromX: rect.right,
+                        fromY: rect.top + rect.height / 2,
+                        toY: rect.top + rect.height / 2,
+                        toX: byKind.completedMaterial ? byKind.completedMaterial.left + 2 : container.right - 10,
+                        curveDirection: 1,
+                    });
+                }
+                else {
+                    let dest;
+                    let lastSlotUsed;
+                    if (mat.action.unloadIntoQueue) {
+                        dest = byKind.queues.get(mat.action.unloadIntoQueue);
+                        lastSlotUsed = queueDestUsed.get(mat.action.unloadIntoQueue) ?? 0;
+                        queueDestUsed.set(mat.action.unloadIntoQueue, lastSlotUsed + 1);
+                    }
+                    else {
+                        dest = byKind.freeMaterial;
+                        lastSlotUsed = lastFreeUsed;
+                        lastFreeUsed += 1;
+                    }
+                    arrows.push({
+                        fromX: rect.left,
+                        fromY: rect.top + rect.height / 2,
+                        toX: dest !== undefined ? dest.right - 5 : container.left + 2,
+                        toY: dest !== undefined ? dest.top + 20 * (lastSlotUsed + 1) : rect.top + rect.height / 2,
+                        curveDirection: 1,
+                    });
+                }
+                break;
+            case api.ActionType.Loading:
+                if (mat.action.loadOntoFace) {
+                    if (mat.location.type === api.LocType.OnPallet) {
+                        if (mat.location.palletNum === mat.action.loadOntoPalletNum &&
+                            mat.location.face === mat.action.loadOntoFace) {
+                            // reclamp
+                            arrows.push({
+                                fromX: rect.right,
+                                fromY: rect.top + (rect.height * 3) / 4,
+                                toX: rect.left + (rect.width * 7) / 8,
+                                toY: rect.bottom,
+                                curveDirection: -1,
+                            });
+                        }
+                        else {
+                            // move to different face
+                            const face = byKind.faces.get(mat.action.loadOntoFace);
+                            if (face) {
+                                if (mat.action.loadOntoFace < (mat.location.face ?? 0)) {
+                                    arrows.push({
+                                        fromX: rect.left,
+                                        fromY: rect.top + rect.height / 2,
+                                        toX: rect.left,
+                                        toY: face.bottom + 20,
+                                        curveDirection: -1,
+                                    });
+                                }
+                                else {
+                                    arrows.push({
+                                        fromX: rect.left,
+                                        fromY: rect.top + rect.height / 2,
+                                        toX: rect.left,
+                                        toY: face.top - 20,
+                                        curveDirection: 1,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // loading from queues or free Material
+                        const face = byKind.faces.get(mat.action.loadOntoFace);
+                        if (face !== undefined) {
+                            const faceSpotsUsed = faceDestUsed.get(mat.action.loadOntoFace) ?? 0;
+                            faceDestUsed.set(mat.action.loadOntoFace, faceSpotsUsed + 1);
+                            arrows.push({
+                                fromX: rect.right,
+                                fromY: rect.top + rect.height / 2,
+                                toX: face.left + 20,
+                                toY: face.top + 50 + 20 * faceSpotsUsed,
+                                curveDirection: -1,
+                            });
+                        }
+                    }
+                }
+                break;
+        }
+    }
+    return arrows.map((arr) => ({
+        fromX: arr.fromX - container.left,
+        fromY: arr.fromY - container.top,
+        toX: arr.toX - container.left,
+        toY: arr.toY - container.top,
+        curveDirection: arr.curveDirection,
+    }));
+}

package/dist/data/operators.d.ts

@@ -0,0 +1,2 @@
+export declare const allOperators: import("jotai").WritableAtom<readonly string[], [readonly string[] | typeof import("jotai/utils").RESET | ((prev: readonly string[]) => readonly string[] | typeof import("jotai/utils").RESET)], void>;
+export declare const currentOperator: import("jotai").WritableAtom<string | null, [newVal: string | null], void>;

package/dist/data/operators.js

@@ -0,0 +1,44 @@
+/* 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 { fmsInformation } from "../network/server-settings.js";
+import { atomWithStorage } from "jotai/utils";
+import { atom } from "jotai";
+const selectedOperator = atomWithStorage("current-operator", null);
+export const allOperators = atomWithStorage("operators", []);
+export const currentOperator = atom((get) => {
+    const selected = get(selectedOperator);
+    const fmsInfo = get(fmsInformation);
+    return fmsInfo.user ? fmsInfo.user.profile.name || fmsInfo.user.profile.sub || null : selected;
+}, (_, set, newVal) => {
+    set(selectedOperator, newVal);
+});

package/dist/data/part-summary.d.ts

@@ -0,0 +1,17 @@
+import { OrderedMap, OrderedSet } from "@seedtactics/immutable-collections";
+import { MaterialSummaryAndCompletedData } from "../cell-status/material-summary";
+export type PartSummary = {
+    readonly part: string;
+    readonly completedQty: number;
+    readonly abnormalQty: number;
+    readonly stationMins: OrderedMap<string, {
+        readonly isLoadUnload: boolean;
+        readonly active: number;
+        readonly elapsed: number;
+        readonly medianElapsed: number;
+    }>;
+    readonly mats: ReadonlyArray<MaterialSummaryAndCompletedData>;
+    readonly workorders: OrderedSet<string>;
+};
+export declare const last30PartSummaryRange: import("./chart-times").Last30ChartRangeAtom;
+export declare const last30PartSummary: import("jotai").Atom<readonly PartSummary[]>;