@seedtactics/insight-client 16.4.0

package/dist/network/backend-mock.d.ts

@@ -0,0 +1,11 @@
+export type MockEvents = ReadonlyArray<object>;
+export interface MockData {
+    readonly curSt: object;
+    readonly jobs: ReadonlyArray<object>;
+    readonly tools: ReadonlyArray<object>;
+    readonly programs: ReadonlyArray<object>;
+    readonly toolUse: {
+        [evtCounter: string]: object;
+    };
+}
+export declare function registerMockBackend(offsetSeconds: number, mockD: Promise<MockData>, mockEvts: Promise<MockEvents>): void;

package/dist/network/backend-mock.js

@@ -0,0 +1,512 @@
+/* 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 { addSeconds } from "date-fns";
+import * as api from "./api.js";
+import { registerBackend } from "./backend.js";
+import { LazySeq, mkCompareByProperties } from "@seedtactics/immutable-collections";
+function offsetJob(j, offsetSeconds) {
+    j.routeStartUTC = addSeconds(j.routeStartUTC, offsetSeconds);
+    j.routeEndUTC = addSeconds(j.routeEndUTC, offsetSeconds);
+    for (const proc of j.procsAndPaths) {
+        for (const path of proc.paths) {
+            path.simulatedStartingUTC = addSeconds(path.simulatedStartingUTC, offsetSeconds);
+            for (const prod of path.simulatedProduction || []) {
+                prod.timeUTC = addSeconds(prod.timeUTC, offsetSeconds);
+            }
+        }
+    }
+}
+function transformTime(offsetSeconds, mockD) {
+    const status = api.CurrentStatus.fromJS(mockD.curSt);
+    status.timeOfCurrentStatusUTC = addSeconds(status.timeOfCurrentStatusUTC, offsetSeconds);
+    for (const j of Object.values(status.jobs)) {
+        offsetJob(j, offsetSeconds);
+    }
+    for (const m of status.material) {
+        if (m.location.face && typeof m.location.face === "string") {
+            m.location.face = parseInt(m.location.face, 10);
+        }
+    }
+    for (const w of status.workorders ?? []) {
+        w.dueDate = addSeconds(w.dueDate, offsetSeconds);
+        for (const c of w.comments ?? []) {
+            c.timeUTC = addSeconds(c.timeUTC, offsetSeconds);
+        }
+    }
+    const allNewJobs = mockD.jobs.map(api.NewJobs.fromJS);
+    const historicJobs = {};
+    for (const newJ of allNewJobs) {
+        for (const j of newJ.jobs) {
+            offsetJob(j, offsetSeconds);
+            historicJobs[j.unique] = new api.HistoricJob({
+                ...j,
+                copiedToSystem: false,
+                scheduleId: newJ.scheduleId,
+            });
+        }
+        for (const s of newJ.stationUse || []) {
+            s.startUTC = addSeconds(s.startUTC, offsetSeconds);
+            s.endUTC = addSeconds(s.endUTC, offsetSeconds);
+        }
+        for (const w of newJ.currentUnfilledWorkorders || []) {
+            w.dueDate = addSeconds(w.dueDate, offsetSeconds);
+        }
+    }
+    const historic = {
+        jobs: historicJobs,
+        stationUse: LazySeq.of(allNewJobs)
+            .flatMap((j) => j.stationUse || [])
+            .toMutableArray(),
+    };
+    return {
+        curSt: status,
+        jobs: historic,
+        workorders: new Map(),
+        tools: mockD.tools.map(api.ToolInMachine.fromJS),
+        programs: mockD.programs.map(api.ProgramInCellController.fromJS),
+    };
+}
+async function loadEventsJson(offsetSeconds, mockD, evts) {
+    const toolUse = (await mockD).toolUse;
+    return LazySeq.of(await evts)
+        .map((evtJson) => {
+        const tools = toolUse[evtJson.counter.toString()];
+        // the type of pal switched from string to int and I didn't want
+        // to regenerate all the data
+        if ("pal" in evtJson && typeof evtJson.pal === "string") {
+            evtJson.pal = parseInt(evtJson.pal);
+        }
+        const e = api.LogEntry.fromJS(tools ? { ...evtJson, tooluse: tools } : evtJson);
+        e.endUTC = addSeconds(e.endUTC, offsetSeconds);
+        return e;
+    })
+        .filter((e) => {
+        if (e.type === api.LogType.InspectionResult) {
+            // filter out a couple inspection results so they are uninspected
+            // and display as uninspected on the station monitor screen
+            const mid = e.material[0].id;
+            if (mid === 2993 || mid === 2974) {
+                return false;
+            }
+            else {
+                return true;
+            }
+        }
+        else {
+            return true;
+        }
+    })
+        .toMutableArray()
+        .sort(mkCompareByProperties((e) => e.endUTC.getTime(), (e) => e.counter));
+}
+function findMatById(evts, matId) {
+    return LazySeq.of(evts)
+        .flatMap((e) => e.material)
+        .find((m) => m.id === matId);
+}
+export function registerMockBackend(offsetSeconds, mockD, mockEvts) {
+    const data = mockD.then((d) => transformTime(offsetSeconds, d));
+    const events = loadEventsJson(offsetSeconds, mockD, mockEvts);
+    const fmsB = {
+        fMSInformation() {
+            return Promise.resolve({
+                name: "mock",
+                version: "1.0.0",
+                requireScanAtCloseout: false,
+                requireWorkorderBeforeAllowCloseoutComplete: false,
+                additionalLogServers: [],
+                usingLabelPrinterForSerials: false,
+            });
+        },
+        printLabel() {
+            return Promise.resolve();
+        },
+        async parseBarcode(barcode) {
+            barcode ??= "";
+            const commaIdx = barcode.indexOf(",");
+            if (commaIdx >= 0) {
+                barcode = barcode.substring(0, commaIdx);
+            }
+            barcode = barcode.replace(/[^0-9a-zA-Z-_]/g, "");
+            const mat = await serialsToMatId.then((s) => s.get(barcode ?? ""));
+            if (mat) {
+                return {
+                    existingMaterial: new api.MaterialDetails({
+                        materialID: mat.matId,
+                        partName: mat.part,
+                        jobUnique: mat.uniq,
+                        numProcesses: mat.numProc,
+                        serial: barcode,
+                    }),
+                };
+            }
+            else {
+                return {
+                    potentialNewMaterial: new api.ScannedPotentialNewMaterial({
+                        serial: barcode,
+                    }),
+                };
+            }
+        },
+        enableVerboseLoggingForFiveMinutes() {
+            return Promise.resolve();
+        },
+    };
+    const jobsB = {
+        history(_startUTC, _endUTC) {
+            return data.then((d) => d.jobs);
+        },
+        recent(_startUTC, _alreadyKnownSchIds) {
+            return data.then((d) => d.jobs);
+        },
+        currentStatus() {
+            return data.then((d) => d.curSt);
+        },
+        setJobComment(_uniq, _comment) {
+            // do nothing
+            return Promise.resolve();
+        },
+        removeMaterialFromAllQueues(_materialId, _operName) {
+            // do nothing
+            return Promise.resolve();
+        },
+        bulkRemoveMaterialFromQueues() {
+            // do nothing
+            return Promise.resolve();
+        },
+        setMaterialInQueue() {
+            // do nothing
+            return Promise.resolve();
+        },
+        addUnprocessedMaterialToQueue() {
+            // do nothing
+            return Promise.resolve(undefined);
+        },
+        addUnallocatedCastingToQueue() {
+            // do nothing
+            return Promise.resolve([]);
+        },
+        signalMaterialForQuarantine() {
+            return Promise.resolve();
+        },
+        swapMaterialOnPallet() {
+            return Promise.resolve();
+        },
+        invalidatePalletCycle() {
+            return Promise.resolve(null);
+        },
+        unscheduledRebookings() {
+            return Promise.resolve([]);
+        },
+    };
+    const serialsToMatId = data.then(() => events.then((evts) => LazySeq.of(evts)
+        .filter((e) => e.type === api.LogType.PartMark)
+        .flatMap((e) => e.material.map((m) => [e.result, { matId: m.id, part: m.part, uniq: m.uniq, numProc: m.numproc }]))
+        .toRMap((x) => x, (id1, id2) => id2)));
+    const logB = {
+        get(startUTC, endUTC) {
+            return data.then(() => events.then((evts) => evts.filter((e) => e.endUTC >= startUTC && e.endUTC <= endUTC)));
+        },
+        recent(_lastSeenCounter) {
+            // no recent events, everything is static
+            return Promise.resolve([]);
+        },
+        logForMaterial(materialID) {
+            return data.then(() => events.then((evts) => evts.filter((e) => LazySeq.of(e.material).some((m) => m.id === materialID))));
+        },
+        logForMaterials(materialIDs) {
+            const matIds = new Set(materialIDs);
+            return data.then(() => events.then((evts) => evts.filter((e) => LazySeq.of(e.material).some((m) => matIds.has(m.id)))));
+        },
+        logForSerial(serial) {
+            return serialsToMatId.then((s) => {
+                const mId = s.get(serial);
+                if (mId !== undefined) {
+                    return this.logForMaterial(mId.matId);
+                }
+                else {
+                    return Promise.resolve([]);
+                }
+            });
+        },
+        async materialForSerial(serial) {
+            if (!serial || serial === "")
+                return [];
+            const mat = await serialsToMatId.then((s) => s.get(serial));
+            if (mat === undefined)
+                return [];
+            return [
+                {
+                    materialID: mat.matId,
+                    jobUnique: mat.uniq,
+                    partName: mat.part,
+                    numProcesses: mat.numProc,
+                    workorder: undefined,
+                    serial: serial,
+                    paths: undefined,
+                },
+            ];
+        },
+        async setInspectionDecision(materialID, inspType, process, inspect) {
+            const evtMat = findMatById(await events, materialID) ??
+                new api.LogMaterial({
+                    id: materialID,
+                    uniq: "",
+                    part: "",
+                    proc: process,
+                    numproc: 1,
+                    face: 1,
+                });
+            const evt = {
+                counter: 0,
+                material: [evtMat],
+                pal: 0,
+                type: api.LogType.Inspection,
+                startofcycle: false,
+                endUTC: new Date(),
+                loc: "Inspection",
+                locnum: 1,
+                result: inspect.toString(),
+                program: "",
+                elapsed: "00:00:00",
+                active: "00:00:00",
+                details: {
+                    InspectionType: inspType,
+                },
+            };
+            return data.then(() => events.then((evts) => {
+                evts.push(evt);
+                return evt;
+            }));
+        },
+        async recordInspectionCompleted(insp) {
+            const evtMat = findMatById(await events, insp.materialID) ??
+                new api.LogMaterial({
+                    id: insp.materialID,
+                    uniq: "",
+                    part: "",
+                    proc: insp.process,
+                    numproc: 1,
+                    face: 1,
+                });
+            const evt = {
+                counter: 0,
+                material: [evtMat],
+                pal: 0,
+                type: api.LogType.InspectionResult,
+                startofcycle: false,
+                endUTC: new Date(),
+                loc: "InspectionComplete",
+                locnum: insp.inspectionLocationNum,
+                result: insp.success.toString(),
+                program: insp.inspectionType ?? "",
+                elapsed: insp.elapsed,
+                active: insp.active,
+                details: insp.extraData,
+            };
+            return data.then(() => events.then((evts) => {
+                evts.push(evt);
+                return evt;
+            }));
+        },
+        async recordCloseoutCompleted(closeout) {
+            const evtMat = findMatById(await events, closeout.materialID) ??
+                new api.LogMaterial({
+                    id: closeout.materialID,
+                    uniq: "",
+                    part: "",
+                    proc: closeout.process,
+                    numproc: 1,
+                    face: 1,
+                });
+            const evt = {
+                counter: 0,
+                material: [evtMat],
+                pal: 0,
+                type: api.LogType.CloseOut,
+                startofcycle: false,
+                endUTC: new Date(),
+                loc: "CloseOut",
+                locnum: closeout.locationNum,
+                result: "",
+                program: "",
+                elapsed: closeout.elapsed,
+                active: closeout.active,
+                details: closeout.extraData,
+            };
+            return data.then(() => events.then((evts) => {
+                evts.push(evt);
+                return evt;
+            }));
+        },
+        async setWorkorder(materialID, process, workorder) {
+            const evtMat = findMatById(await events, materialID) ??
+                new api.LogMaterial({
+                    id: materialID,
+                    uniq: "",
+                    part: "",
+                    proc: process,
+                    numproc: 1,
+                    face: 1,
+                });
+            const evt = {
+                counter: 0,
+                material: [evtMat],
+                pal: 0,
+                type: api.LogType.OrderAssignment,
+                startofcycle: false,
+                endUTC: new Date(),
+                loc: "OrderAssignment",
+                locnum: 1,
+                result: workorder,
+                program: "",
+                elapsed: "00:00:00",
+                active: "00:00:00",
+            };
+            return data.then(() => events.then((evts) => {
+                evts.push(evt);
+                return evt;
+            }));
+        },
+        getActiveWorkorder() {
+            return Promise.resolve([]);
+        },
+        recordOperatorNotes(materialID, process, operatorName, notes) {
+            const mat = new api.LogMaterial({
+                id: materialID,
+                uniq: "",
+                part: "",
+                proc: process,
+                numproc: 1,
+                face: 0,
+            });
+            const evt = {
+                counter: 0,
+                material: [mat],
+                pal: 0,
+                type: api.LogType.GeneralMessage,
+                startofcycle: false,
+                endUTC: new Date(),
+                loc: "Message",
+                locnum: 1,
+                result: "Operator Notes",
+                program: "OperatorNotes",
+                elapsed: "00:00:00",
+                active: "00:00:00",
+                details: {
+                    operator: operatorName || "",
+                    note: notes,
+                },
+            };
+            return data.then(() => events.then((evts) => {
+                evts.push(evt);
+                return evt;
+            }));
+        },
+        recordWorkorderComment(workorder, operName, comment) {
+            return Promise.resolve({
+                counter: 0,
+                material: [],
+                pal: 0,
+                type: api.LogType.WorkorderComment,
+                startofcycle: false,
+                endUTC: new Date(),
+                loc: "WorkorderComment",
+                locnum: 1,
+                result: workorder,
+                program: "",
+                elapsed: "PT0S",
+                active: "PT0S",
+                details: {
+                    Comment: comment,
+                    Operator: operName ?? "",
+                },
+            });
+        },
+        cancelRebooking(bookingId) {
+            return Promise.resolve({
+                counter: 0,
+                material: [],
+                pal: 0,
+                type: api.LogType.CancelRebooking,
+                startofcycle: false,
+                endUTC: new Date(),
+                loc: "Rebooking",
+                locnum: 1,
+                result: bookingId,
+                program: "",
+                elapsed: "PT0S",
+                active: "PT0S",
+            });
+        },
+        requestRebooking(partName, qty, workorder, priority, notes) {
+            return Promise.resolve({
+                counter: 0,
+                material: [],
+                pal: 0,
+                type: api.LogType.Rebooking,
+                startofcycle: false,
+                endUTC: new Date(),
+                loc: "Rebooking",
+                locnum: priority ?? 0,
+                result: "Rebooking",
+                program: partName,
+                elapsed: "PT0S",
+                active: "PT0S",
+                details: {
+                    Quantity: qty?.toString() ?? "1",
+                    Workorder: workorder ?? "",
+                    Notes: notes ?? "",
+                },
+            });
+        },
+    };
+    const machineB = {
+        getToolsInMachines() {
+            return data.then((d) => d.tools ?? []);
+        },
+        getProgramsInCellController() {
+            return data.then((d) => d.programs ?? []);
+        },
+        getProgramRevisionContent(program) {
+            return Promise.resolve("GCODE for " + program + " would be here");
+        },
+        getLatestProgramRevisionContent(program) {
+            return Promise.resolve("GCODE for " + program + " would be here");
+        },
+        getProgramRevisionsInDescendingOrderOfRevision() {
+            return Promise.resolve([]);
+        },
+    };
+    registerBackend(logB, jobsB, fmsB, machineB);
+}

package/dist/network/backend.d.ts

@@ -0,0 +1,57 @@
+import * as api from "./api.js";
+import { User } from "oidc-client-ts";
+export interface JobAPI {
+    history(startUTC: Date, endUTC: Date): Promise<Readonly<api.IHistoricData>>;
+    recent(startUTC: Date, alreadyKnownSchIds: string[]): Promise<Readonly<api.IRecentHistoricData>>;
+    currentStatus(): Promise<Readonly<api.ICurrentStatus>>;
+    setJobComment(unique: string, comment: string): Promise<void>;
+    removeMaterialFromAllQueues(materialId: number, operatorName: string | undefined): Promise<void>;
+    bulkRemoveMaterialFromQueues(operatorName: string | null, materialIds: ReadonlyArray<number> | null): Promise<void>;
+    setMaterialInQueue(materialId: number, operatorName: string | null, queue: api.QueuePosition): Promise<void>;
+    addUnprocessedMaterialToQueue(jobUnique: string, lastCompletedProcess: number, queue: string, pos: number, operatorName: string | null, workorder: string | null, serial: string): Promise<Readonly<api.IInProcessMaterial> | undefined>;
+    addUnallocatedCastingToQueue(castingName: string, queue: string, qty: number, operatrorName: string | null, workorder: string | null, serials: string[]): Promise<ReadonlyArray<Readonly<api.IInProcessMaterial>>>;
+    signalMaterialForQuarantine(materialId: number, operName: string | null, reason: string | undefined): Promise<void>;
+    swapMaterialOnPallet(materialId: number, operName: string | null, mat: Readonly<api.IMatToPutOnPallet>): Promise<void>;
+    invalidatePalletCycle(materialId: number, operName: string | null | undefined, changeCastingTo: string | null | undefined, changeJobUniqueTo: string | null | undefined, process: number): Promise<Readonly<api.IMaterialDetails> | null | undefined>;
+    unscheduledRebookings(signal?: AbortSignal): Promise<ReadonlyArray<Readonly<api.IRebooking>>>;
+}
+export interface FmsAPI {
+    fMSInformation(): Promise<Readonly<api.IFMSInfo>>;
+    printLabel(materialId: number, process: number): Promise<void>;
+    parseBarcode(barcode: string | null, queuesToAddTo: ReadonlyArray<string> | null | undefined): Promise<Readonly<api.IScannedMaterial | null>>;
+    enableVerboseLoggingForFiveMinutes(): Promise<void>;
+}
+export interface LogAPI {
+    get(startUTC: Date, endUTC: Date, signal?: AbortSignal): Promise<ReadonlyArray<Readonly<api.ILogEntry>>>;
+    recent(lastSeenCounter: number, expectedEndUTCofLastSeen: Date | null | undefined): Promise<ReadonlyArray<Readonly<api.ILogEntry>>>;
+    logForMaterial(materialID: number, signal?: AbortSignal): Promise<ReadonlyArray<Readonly<api.ILogEntry>>>;
+    logForMaterials(materialIDs: ReadonlyArray<number> | null | undefined): Promise<ReadonlyArray<Readonly<api.ILogEntry>>>;
+    logForSerial(serial: string, signal?: AbortSignal): Promise<ReadonlyArray<Readonly<api.ILogEntry>>>;
+    materialForSerial(serial: string | null): Promise<ReadonlyArray<Readonly<api.IMaterialDetails>>>;
+    setInspectionDecision(materialID: number, inspType: string, process: number, inspect: boolean): Promise<Readonly<api.ILogEntry>>;
+    recordInspectionCompleted(insp: api.NewInspectionCompleted): Promise<Readonly<api.ILogEntry>>;
+    recordCloseoutCompleted(insp: api.NewCloseout): Promise<Readonly<api.ILogEntry>>;
+    setWorkorder(materialID: number, process: number, workorder: string): Promise<Readonly<api.ILogEntry>>;
+    recordOperatorNotes(materialID: number, process: number, operatorName: string | null, notes: string): Promise<Readonly<api.ILogEntry>>;
+    recordWorkorderComment(workorder: string, operName: string | null | undefined, comment: string): Promise<Readonly<api.ILogEntry>>;
+    getActiveWorkorder(workorder: string, signal?: AbortSignal): Promise<ReadonlyArray<Readonly<api.IActiveWorkorder>>>;
+    cancelRebooking(bookingId: string): Promise<Readonly<api.ILogEntry>>;
+    requestRebooking(partName: string, qty: number | undefined, workorder: string | null | undefined, priority: number | null | undefined, notes: string | undefined): Promise<Readonly<api.ILogEntry>>;
+}
+export interface MachineAPI {
+    getToolsInMachines(): Promise<ReadonlyArray<Readonly<api.IToolInMachine>>>;
+    getProgramsInCellController(): Promise<ReadonlyArray<Readonly<api.IProgramInCellController>>>;
+    getProgramRevisionContent(program: string, revision: number): Promise<string>;
+    getLatestProgramRevisionContent(program: string): Promise<string>;
+    getProgramRevisionsInDescendingOrderOfRevision(programName: string | null, count: number, revisionToStart: number | undefined): Promise<ReadonlyArray<Readonly<api.IProgramRevision>>>;
+}
+export declare let FmsServerBackend: FmsAPI;
+export declare let JobsBackend: JobAPI;
+export declare let LogBackend: LogAPI;
+export declare let MachineBackend: MachineAPI;
+export declare let OtherLogBackends: ReadonlyArray<LogAPI>;
+export declare function registerNetworkBackend(): void;
+export declare function setOtherLogBackends(servers: ReadonlyArray<string>): void;
+export declare function registerBackend(log: LogAPI, job: JobAPI, fms: FmsAPI, machine: MachineAPI): void;
+export declare function setUserToken(u: User): void;
+export declare function instructionUrl(partName: string, type: string, matId: number, pallet: number | null, proc: number | null | undefined, operator: string | null): string;

package/dist/network/backend.js

@@ -0,0 +1,77 @@
+/* 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 * as api from "./api.js";
+export let FmsServerBackend;
+export let JobsBackend;
+export let LogBackend;
+export let MachineBackend;
+let otherLogServers = [];
+export let OtherLogBackends = [];
+export function registerNetworkBackend() {
+    LogBackend = new api.LogClient();
+    MachineBackend = new api.MachinesClient();
+    JobsBackend = new api.JobsClient();
+    FmsServerBackend = new api.FmsClient();
+}
+export function setOtherLogBackends(servers) {
+    otherLogServers = servers;
+    OtherLogBackends = servers.map((s) => new api.LogClient(s));
+}
+export function registerBackend(log, job, fms, machine) {
+    LogBackend = log;
+    JobsBackend = job;
+    FmsServerBackend = fms;
+    MachineBackend = machine;
+}
+export function setUserToken(u) {
+    const token = u.access_token;
+    function fetch(url, init) {
+        return window.fetch(url, init
+            ? { ...init, headers: { ...init.headers, Authorization: "Bearer " + token } }
+            : { headers: { Authorization: "Bearer " + token } });
+    }
+    FmsServerBackend = new api.FmsClient(undefined, { fetch });
+    JobsBackend = new api.JobsClient(undefined, { fetch });
+    LogBackend = new api.LogClient(undefined, { fetch });
+    OtherLogBackends = otherLogServers.map((s) => new api.LogClient(s, { fetch }));
+}
+export function instructionUrl(partName, type, matId, pallet, proc, operator) {
+    return ("/api/v1/fms/find-instructions/" +
+        encodeURIComponent(partName) +
+        "?type=" +
+        encodeURIComponent(type) +
+        ("&materialID=" + matId.toString()) +
+        (proc !== null && proc !== undefined ? "&process=" + proc.toString() : "") +
+        (operator !== null ? "&operatorName=" + encodeURIComponent(operator) : "") +
+        (pallet ? "&pallet=" + encodeURIComponent(pallet) : ""));
+}

package/dist/network/load-specific-month.d.ts

@@ -0,0 +1,13 @@
+import { Atom } from "jotai";
+export declare const selectedMonth: import("jotai").WritableAtom<Date, [m: Date], void>;
+export type SelectedAnalysisPeriod = {
+    type: "Last30";
+} | {
+    type: "SpecificMonth";
+    month: Date;
+};
+export declare const selectedAnalysisPeriod: Atom<SelectedAnalysisPeriod>;
+export declare const loadingSpecificMonthData: Atom<boolean>;
+export declare const errorLoadingSpecificMonthData: Atom<string | null>;
+export declare function useSetLast30(): () => void;
+export declare function useSetSpecificMonthWithoutLoading(): (m: Date) => void;