@adcops/autocore-react 3.3.50 → 3.3.57

package/src/components/tis/TisProvider.tsx

@@ -0,0 +1,405 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * <TisProvider> — wires the four TIS HMI components into the running
+ * server without any manual prop-threading. It owns:
+ *
+ *   1. The schema registry (loaded once via `tis.list_schemas`).
+ *   2. The four live readiness scalars (`tis.staged*`, `tis.active*`).
+ *   3. The selection state (project, method, sample, run) — each field
+ *      follows its `active_*` scalar by default until a component pins
+ *      it explicitly via `setSelection`.
+ *   4. A run cache that tracks live cycle/results broadcasts so detail
+ *      views re-render in place when the control program appends data.
+ *
+ * Drop it once at the top of the HMI; the four TIS components below it
+ * read from context and need no props.
+ */
+
+import React, {
+    createContext,
+    useCallback,
+    useContext,
+    useEffect,
+    useMemo,
+    useReducer,
+    useRef,
+    useState,
+    type ReactNode,
+} from 'react';
+import { EventEmitterContext } from '../../core/EventEmitterContext';
+import { MessageType } from '../../hub/CommandMessage';
+
+// -------------------------------------------------------------------------
+// Types
+// -------------------------------------------------------------------------
+
+/**
+ * One slot in the schema registry. Kept as an opaque object so the
+ * provider doesn't have to mirror every schema field — components that
+ * need typed access import the schema constants from the per-project
+ * generated `autocore/tis.ts` instead.
+ */
+export type TisMethodSchema = any;
+
+export type SchemaRegistry = { [methodId: string]: TisMethodSchema };
+
+export interface TisLiveState {
+    staged: boolean;
+    stagedProjectId: string;
+    stagedMethodId: string;
+    stagedSampleId: string;
+
+    active: boolean;
+    activeProjectId: string;
+    activeMethodId: string;
+    activeSampleId: string;
+    activeRunId: string;
+}
+
+export interface TisSelection {
+    projectId: string;
+    methodId: string;
+    sampleId: string;
+    runId: string;
+}
+
+/** Partial setter — pass `null` for a field to clear the pin and let
+ *  the active scalar drive that field again. */
+export type TisSelectionPatch = {
+    projectId?: string | null;
+    methodId?: string | null;
+    sampleId?: string | null;
+    runId?: string | null;
+};
+
+export interface TisRunCacheEntry {
+    meta: any | null;
+    cycles: any[];
+    results: any;
+    rawData: { [blobName: string]: any };
+}
+
+export interface TisContextValue {
+    schemas: SchemaRegistry;
+    defaultMethodId: string;
+    schemasLoaded: boolean;
+
+    state: TisLiveState;
+
+    selection: TisSelection;
+    setSelection: (patch: TisSelectionPatch) => void;
+
+    /** Fetch the run list for a (project, method?) pair. Method may be
+     *  omitted to aggregate runs across every method in the project —
+     *  the History tab uses this. */
+    fetchRuns: (projectId: string, methodId?: string) => Promise<any[]>;
+    /** Fetch the full bundle (test.json + cycles + results) for one run.
+     *  Subsequent broadcast deltas land in the cache automatically. */
+    fetchRun: (projectId: string, methodId: string, runId: string) => Promise<TisRunCacheEntry | null>;
+    runCache: { [runId: string]: TisRunCacheEntry };
+}
+
+// -------------------------------------------------------------------------
+// Defaults
+// -------------------------------------------------------------------------
+
+const EMPTY_STATE: TisLiveState = {
+    staged: false, stagedProjectId: '', stagedMethodId: '', stagedSampleId: '',
+    active: false, activeProjectId: '', activeMethodId: '', activeSampleId: '', activeRunId: '',
+};
+
+const EMPTY_SELECTION: TisSelection = {
+    projectId: '', methodId: '', sampleId: '', runId: '',
+};
+
+const TisContext = createContext<TisContextValue>({
+    schemas: {},
+    defaultMethodId: '',
+    schemasLoaded: false,
+    state: EMPTY_STATE,
+    selection: EMPTY_SELECTION,
+    setSelection: () => {},
+    fetchRuns: async () => [],
+    fetchRun: async () => null,
+    runCache: {},
+});
+
+// -------------------------------------------------------------------------
+// Reducer for live broadcast state
+// -------------------------------------------------------------------------
+
+type StateAction =
+    | { kind: 'staged'; value: boolean }
+    | { kind: 'staged_project_id'; value: string }
+    | { kind: 'staged_method_id'; value: string }
+    | { kind: 'staged_sample_id'; value: string }
+    | { kind: 'active'; value: boolean }
+    | { kind: 'active_project_id'; value: string }
+    | { kind: 'active_method_id'; value: string }
+    | { kind: 'active_sample_id'; value: string }
+    | { kind: 'active_run_id'; value: string };
+
+function liveReducer(s: TisLiveState, a: StateAction): TisLiveState {
+    switch (a.kind) {
+        case 'staged':              return { ...s, staged: a.value };
+        case 'staged_project_id':   return { ...s, stagedProjectId: a.value };
+        case 'staged_method_id':    return { ...s, stagedMethodId: a.value };
+        case 'staged_sample_id':    return { ...s, stagedSampleId: a.value };
+        case 'active':              return { ...s, active: a.value };
+        case 'active_project_id':   return { ...s, activeProjectId: a.value };
+        case 'active_method_id':    return { ...s, activeMethodId: a.value };
+        case 'active_sample_id':    return { ...s, activeSampleId: a.value };
+        case 'active_run_id':       return { ...s, activeRunId: a.value };
+    }
+}
+
+// -------------------------------------------------------------------------
+// Provider
+// -------------------------------------------------------------------------
+
+export interface TisProviderProps {
+    children: ReactNode;
+    /**
+     * Initial method_id when the schemas haven't loaded yet, or when the
+     * server's reported `default_method_id` is empty. Falls through to
+     * the first key of `tis.list_schemas` if not supplied.
+     */
+    defaultMethodId?: string;
+}
+
+export const TisProvider: React.FC<TisProviderProps> = ({ children, defaultMethodId: initialDefault }) => {
+    const { invoke, subscribe, unsubscribe } = useContext(EventEmitterContext);
+
+    const [schemas, setSchemas] = useState<SchemaRegistry>({});
+    const [defaultMethodId, setDefaultMethodId] = useState<string>(initialDefault ?? '');
+    const [schemasLoaded, setSchemasLoaded] = useState(false);
+
+    const [state, dispatch] = useReducer(liveReducer, EMPTY_STATE);
+
+    // Selection has two layers: explicit pins (set via setSelection) and
+    // an "active follower" fallback. Storing pins as `null` means
+    // "follow active"; storing `''` means "explicitly empty" (e.g.,
+    // user cleared the field). Only `null` triggers the follow.
+    const [pins, setPins] = useState<{
+        projectId: string | null;
+        methodId: string | null;
+        sampleId: string | null;
+        runId: string | null;
+    }>({
+        projectId: null, methodId: null, sampleId: null, runId: null,
+    });
+
+    // -----------------------------------------------------------------
+    // Schema load — once on mount. The Hub's `invoke()` queues sends
+    // while the WS is still CONNECTING and flushes them on `onopen`,
+    // so this works whether or not the handshake has finished yet.
+    // -----------------------------------------------------------------
+    useEffect(() => {
+        let cancelled = false;
+        (async () => {
+            try {
+                const resp: any = await invoke('tis.list_schemas' as any, MessageType.Request, {} as any);
+                if (cancelled) return;
+                if (resp?.success && resp.data) {
+                    const methods = (resp.data.test_methods ?? {}) as SchemaRegistry;
+                    const dflt    = (resp.data.default_method_id ?? '') as string;
+                    setSchemas(methods);
+                    if (!initialDefault && dflt) setDefaultMethodId(dflt);
+                    setSchemasLoaded(true);
+                } else {
+                    console.warn('[TisProvider] tis.list_schemas failed:', resp?.error_message);
+                }
+            } catch (e) {
+                console.error('[TisProvider] tis.list_schemas threw:', e);
+            }
+        })();
+        return () => { cancelled = true; };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+
+    // -----------------------------------------------------------------
+    // Live readiness scalars — subscribe to every tis.* broadcast
+    // -----------------------------------------------------------------
+    useEffect(() => {
+        const subs = [
+            subscribe('tis.staged',              (v: any) => dispatch({ kind: 'staged',              value: !!v })),
+            subscribe('tis.staged_project_id',   (v: any) => dispatch({ kind: 'staged_project_id',   value: String(v ?? '') })),
+            subscribe('tis.staged_method_id',    (v: any) => dispatch({ kind: 'staged_method_id',    value: String(v ?? '') })),
+            subscribe('tis.staged_sample_id',    (v: any) => dispatch({ kind: 'staged_sample_id',    value: String(v ?? '') })),
+            subscribe('tis.active',              (v: any) => dispatch({ kind: 'active',              value: !!v })),
+            subscribe('tis.active_project_id',   (v: any) => dispatch({ kind: 'active_project_id',   value: String(v ?? '') })),
+            subscribe('tis.active_method_id',    (v: any) => dispatch({ kind: 'active_method_id',    value: String(v ?? '') })),
+            subscribe('tis.active_sample_id',    (v: any) => dispatch({ kind: 'active_sample_id',    value: String(v ?? '') })),
+            subscribe('tis.active_run_id',       (v: any) => dispatch({ kind: 'active_run_id',       value: String(v ?? '') })),
+        ];
+        return () => { subs.forEach(unsubscribe); };
+    }, [subscribe, unsubscribe]);
+
+    // -----------------------------------------------------------------
+    // Run cache — broadcasts of cycles/results land here so detail
+    // views can subscribe via useTisRun() instead of re-fetching.
+    // -----------------------------------------------------------------
+    const cacheRef = useRef<{ [runId: string]: TisRunCacheEntry }>({});
+    // bumpCacheVersion is a numeric tick; we expose `runCache` as a
+    // memoised value derived from the ref so React rerenders dependent
+    // components when any run entry changes.
+    const [cacheVersion, setCacheVersion] = useState(0);
+    const bumpCache = useCallback(() => setCacheVersion(v => v + 1), []);
+
+    const upsertCycle = useCallback((runId: string, cycle: any) => {
+        if (!runId) return;
+        const prev = cacheRef.current[runId] ?? { meta: null, cycles: [], results: {}, rawData: {} };
+        cacheRef.current[runId] = { ...prev, cycles: [...prev.cycles, cycle] };
+        bumpCache();
+    }, [bumpCache]);
+
+    const upsertResults = useCallback((runId: string, results: any) => {
+        if (!runId) return;
+        const prev = cacheRef.current[runId] ?? { meta: null, cycles: [], results: {}, rawData: {} };
+        cacheRef.current[runId] = { ...prev, results };
+        bumpCache();
+    }, [bumpCache]);
+
+    useEffect(() => {
+        const onCycle = (payload: any) => {
+            if (!payload?.run_id || !payload.cycle) return;
+            upsertCycle(payload.run_id, payload.cycle);
+        };
+        const onResults = (payload: any) => {
+            if (!payload?.run_id) return;
+            upsertResults(payload.run_id, payload.results ?? {});
+        };
+        const id1 = subscribe('tis.cycle_added',     onCycle);
+        const id2 = subscribe('tis.results_updated', onResults);
+        return () => { unsubscribe(id1); unsubscribe(id2); };
+    }, [subscribe, unsubscribe, upsertCycle, upsertResults]);
+
+    // -----------------------------------------------------------------
+    // Selection: pins override active
+    // -----------------------------------------------------------------
+    const selection: TisSelection = useMemo(() => ({
+        projectId: pins.projectId ?? state.activeProjectId,
+        methodId:  pins.methodId  ?? (state.activeMethodId || defaultMethodId),
+        sampleId:  pins.sampleId  ?? state.activeSampleId,
+        runId:     pins.runId     ?? state.activeRunId,
+    }), [pins, state, defaultMethodId]);
+
+    const setSelection = useCallback((patch: TisSelectionPatch) => {
+        setPins(prev => ({
+            projectId: patch.projectId === undefined ? prev.projectId : patch.projectId,
+            methodId:  patch.methodId  === undefined ? prev.methodId  : patch.methodId,
+            sampleId:  patch.sampleId  === undefined ? prev.sampleId  : patch.sampleId,
+            runId:     patch.runId     === undefined ? prev.runId     : patch.runId,
+        }));
+    }, []);
+
+    // -----------------------------------------------------------------
+    // Fetchers
+    // -----------------------------------------------------------------
+    const fetchRuns = useCallback(async (projectId: string, methodId?: string): Promise<any[]> => {
+        if (!projectId) return [];
+        const payload: any = { project_id: projectId };
+        if (methodId) payload.method_id = methodId;
+        try {
+            const resp: any = await invoke('tis.list_tests' as any, MessageType.Request, payload);
+            if (resp?.success && resp.data?.tests) return resp.data.tests as any[];
+        } catch (e) {
+            console.error('[TisProvider] tis.list_tests failed:', e);
+        }
+        return [];
+    }, [invoke]);
+
+    const fetchRun = useCallback(async (
+        projectId: string, methodId: string, runId: string,
+    ): Promise<TisRunCacheEntry | null> => {
+        if (!projectId || !methodId || !runId) return null;
+        try {
+            const meta: any = await invoke('tis.read_test' as any, MessageType.Request, {
+                project_id: projectId, method_id: methodId, run_id: runId,
+            } as any);
+            const cy: any = await invoke('tis.read_cycles' as any, MessageType.Request, {
+                project_id: projectId, method_id: methodId, run_id: runId,
+                offset: 0, limit: 1000, order: 'asc',
+            } as any);
+            if (!meta?.success) return null;
+            const entry: TisRunCacheEntry = {
+                meta:    meta.data ?? null,
+                cycles:  (cy?.success ? (cy.data?.cycles ?? []) : []) as any[],
+                results: meta.data?.results ?? {},
+                rawData: cacheRef.current[runId]?.rawData ?? {},
+            };
+            cacheRef.current[runId] = entry;
+            bumpCache();
+            return entry;
+        } catch (e) {
+            console.error('[TisProvider] fetchRun failed:', e);
+            return null;
+        }
+    }, [invoke, bumpCache]);
+
+    const runCache = useMemo(() => ({ ...cacheRef.current }), [cacheVersion]);
+
+    const value: TisContextValue = useMemo(() => ({
+        schemas, defaultMethodId, schemasLoaded,
+        state, selection, setSelection,
+        fetchRuns, fetchRun, runCache,
+    }), [schemas, defaultMethodId, schemasLoaded, state, selection, setSelection, fetchRuns, fetchRun, runCache]);
+
+    return <TisContext.Provider value={value}>{children}</TisContext.Provider>;
+};
+
+// -------------------------------------------------------------------------
+// Hooks
+// -------------------------------------------------------------------------
+
+export const useTis           = () => useContext(TisContext);
+export const useTisSchemas    = () => useContext(TisContext).schemas;
+export const useTisState      = () => useContext(TisContext).state;
+export const useTisSelection  = () => {
+    const { selection, setSelection } = useContext(TisContext);
+    return [selection, setSelection] as const;
+};
+
+export const useTisRuns = (projectId?: string, methodId?: string) => {
+    const { fetchRuns } = useContext(TisContext);
+    const [runs, setRuns] = useState<any[]>([]);
+    const [loading, setLoading] = useState(false);
+    const refresh = useCallback(async () => {
+        if (!projectId) { setRuns([]); return; }
+        setLoading(true);
+        try { setRuns(await fetchRuns(projectId, methodId)); }
+        finally { setLoading(false); }
+    }, [projectId, methodId, fetchRuns]);
+    useEffect(() => { void refresh(); }, [refresh]);
+    return { runs, loading, refresh };
+};
+
+export const useTisRun = (runId?: string) => {
+    const { selection, fetchRun, runCache } = useContext(TisContext);
+    const [loading, setLoading] = useState(false);
+    const targetRunId = runId ?? selection.runId;
+
+    useEffect(() => {
+        if (!targetRunId) return;
+        if (runCache[targetRunId]?.meta) return; // already cached
+        const projectId = selection.projectId;
+        const methodId  = selection.methodId;
+        if (!projectId || !methodId) return;
+        setLoading(true);
+        void fetchRun(projectId, methodId, targetRunId).finally(() => setLoading(false));
+    }, [targetRunId, selection.projectId, selection.methodId, fetchRun, runCache]);
+
+    const entry = targetRunId ? runCache[targetRunId] : null;
+    return {
+        meta:    entry?.meta ?? null,
+        cycles:  entry?.cycles ?? [],
+        results: entry?.results ?? {},
+        rawData: entry?.rawData ?? {},
+        loading,
+    };
+};
+
+// Re-export the context so app code that needs direct access can grab
+// it without importing the hooks (rare).
+export { TisContext };

package/src/hub/HubWebSocket.ts

@@ -98,13 +98,27 @@ function downloadBlob(blob: Blob, filename: string): void {
 export class HubWebSocket extends HubBase {
     private socket: WebSocket;
     private requestId = 0;
-    
-    /** 
+
+    /**
      * Map of pending Transaction ID -> Promise Resolvers.
      * Used to match asynchronous WebSocket responses to their original requests.
      */
     private pendingRequests = new Map<number, RequestRecord>();
 
+    /**
+     * Messages queued while the WebSocket is still in CONNECTING state.
+     * Flushed in `socket.onopen`. Without this queue, an `invoke()` fired
+     * from a React `useEffect` on first mount races the WS handshake —
+     * `socket.send()` on a non-OPEN socket throws a synchronous
+     * DOMException ("object not, or is no longer, usable"), which the
+     * caller sees as an opaque rejection and the underlying request is
+     * never sent.
+     *
+     * Each entry carries the request id so we can reject the matching
+     * pending Promise if the WS closes before we ever flush.
+     */
+    private sendQueue: Array<{ id: number; json: string }> = [];
+
     /**
      * Initializes the WebSocket connection immediately.
      */
@@ -127,6 +141,18 @@ export class HubWebSocket extends HubBase {
         this.socket.onopen = function () {
             console.log("WebSocket connection established.");
             getDebugPanel().wsOpened(wsUrl);
+            // Flush any messages that `invoke()` queued while the WS
+            // was still in CONNECTING. Order is preserved by Array push
+            // / for-of iteration. Done BEFORE publishing HUB/connected
+            // and setIsConnected(true) so any subscriber that fires its
+            // own invoke() in response sees the queue already drained.
+            if (self.sendQueue.length > 0) {
+                console.log(`[HubWebSocket] Flushing ${self.sendQueue.length} queued message(s)`);
+                for (const { json } of self.sendQueue) {
+                    self.socket.send(json);
+                }
+                self.sendQueue = [];
+            }
             // Notify app that we are online
             self.publish("HUB/connected", true);
             self.setIsConnected(true);
@@ -195,6 +221,19 @@ export class HubWebSocket extends HubBase {
             self.setIsConnected(false);
             console.log('WebSocket connection closed.');
             getDebugPanel().wsClosed(event.code, event.reason || 'No reason');
+
+            // Anything queued but never sent must reject — its Promise
+            // is in pendingRequests and would otherwise hang forever.
+            if (self.sendQueue.length > 0) {
+                for (const { id } of self.sendQueue) {
+                    const req = self.pendingRequests.get(id);
+                    if (req) {
+                        req.reject(new Error('WebSocket closed before message could be sent'));
+                        self.pendingRequests.delete(id);
+                    }
+                }
+                self.sendQueue = [];
+            }
         };
     }
 
@@ -224,7 +263,31 @@ export class HubWebSocket extends HubBase {
             };
 
             getDebugPanel().messageSent(MessageType[messageType], topic, id);
-            this.socket.send(JSON.stringify(cm));
+            const json = JSON.stringify(cm);
+
+            // Branch on the WS state. The browser throws a synchronous
+            // DOMException if you send() on a socket that isn't OPEN, so
+            // every consumer would otherwise need its own
+            // `subscribe('HUB/connected', ...)` guard. Centralising it
+            // here means useEffect-on-mount calls "just work" — they
+            // get queued and flushed when the handshake completes.
+            switch (this.socket.readyState) {
+                case WebSocket.OPEN:
+                    this.socket.send(json);
+                    break;
+                case WebSocket.CONNECTING:
+                    this.sendQueue.push({ id, json });
+                    break;
+                default:
+                    // CLOSING / CLOSED — the WS is gone, no point queuing.
+                    // Fail fast so the caller sees a real error instead
+                    // of hanging.
+                    this.pendingRequests.delete(id);
+                    reject(new Error(
+                        `WebSocket not open (readyState=${this.socket.readyState}); ` +
+                        `cannot send '${topic}'`
+                    ));
+            }
         });
     }