@adcops/autocore-react 3.3.83 → 3.3.84

package/src/components/tis/TestSetupForm.tsx

@@ -43,8 +43,22 @@ export interface TestFieldDef {
      *  the control program sees it; for non-source fields it's stashed
      *  straight into stagedConfig. Operator edits override per-stage,
      *  but the schema default never mutates — re-selecting the method
-     *  re-applies the default. */
+     *  re-applies the default. **Authored in display units** when
+     *  `scale` is set — the form divides by `scale` before writing to
+     *  GM / stagedConfig so the underlying storage stays raw. */
     default?: any;
+    /** Optional unit-conversion multiplier. Mirrors AutoCoreTagContext:
+     *  ```
+     *  display = raw * scale
+     *  raw     = display / scale
+     *  ```
+     *  Example: backend stores degrees, operator enters revolutions →
+     *  `scale: 0.00277778`. None / 1.0 = no conversion.
+     *
+     *  Storage stays raw — the form scales only on input and display.
+     *  Cycle and results values are scaled by the corresponding paths
+     *  in TestDataView; the server scales CSV exports too. */
+    scale?: number;
 }
 
 export interface TestMethod {
@@ -104,6 +118,30 @@ const labelOf = (f: TestFieldDef): string => {
     return f.units ? `${base} [${f.units}]` : base;
 };
 
+/**
+ * Two helpers for the display ↔ raw boundary on numeric fields.
+ *
+ * Convention: `display = raw * scale`, `raw = display / scale`. Matches
+ * AutoCoreTagContext. Default scale = 1.0 (no conversion). Non-numeric
+ * input values (string, null, undefined, NaN) pass through unchanged
+ * — the form has fields of other types that share the change handler.
+ *
+ * Storage (config map, GM, on-disk JSON) always holds the raw value.
+ * Only the inputs the operator looks at and the cells in TestDataView
+ * use the display value. This way scales can change in project.json
+ * without invalidating historical records.
+ */
+const rawToDisplay = (raw: any, scale: number | undefined): any => {
+    if (!scale || scale === 1) return raw;
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) return raw;
+    return raw * scale;
+};
+const displayToRaw = (display: any, scale: number | undefined): any => {
+    if (!scale || scale === 1) return display;
+    if (typeof display !== 'number' || !Number.isFinite(display)) return display;
+    return display / scale;
+};
+
 const hasDescription = (f: TestFieldDef): boolean =>
     typeof f.description === 'string' && f.description.length > 0;
 
@@ -265,14 +303,20 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
                 if (field.name === 'sample_id') continue;
                 if (field.default === undefined || field.default === null) continue;
                 if (next === prev) next = { ...prev };
-                next[field.name] = field.default;
+                // Schema defaults are authored in DISPLAY units (per
+                // the agreed convention) so the value the author reads
+                // in project.json matches the field's `units` label.
+                // Convert to raw before storing in stagedConfig / GM
+                // so the rest of the pipeline sees the canonical value.
+                const rawDefault = displayToRaw(field.default, field.scale);
+                next[field.name] = rawDefault;
                 if (field.source) {
                     // Mirror handleFieldChange: write to GM so the
                     // control program sees the default. Errors here are
                     // logged but non-fatal — the form still reflects
                     // the default locally.
                     void Promise.resolve()
-                        .then(() => write(field.source!, field.default))
+                        .then(() => write(field.source!, rawDefault))
                         .catch(e => console.error(
                             `[TestSetupForm] Failed to seed default for ${field.name}:`, e));
                 }
@@ -360,9 +404,13 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
     };
 
     const handleFieldChange = async (field: TestFieldDef, val: any) => {
-        setConfig({ ...config, [field.name]: val });
+        // The operator typed a DISPLAY value; convert to RAW before
+        // storing or writing to GM. Non-numeric fields and identity
+        // scales pass through unchanged via the helper.
+        const rawVal = displayToRaw(val, field.scale);
+        setConfig({ ...config, [field.name]: rawVal });
         if (field.source) {
-            try { await write(field.source, val); }
+            try { await write(field.source, rawVal); }
             catch (e) { console.error('Failed to write to source:', e); }
         }
     };
@@ -417,7 +465,13 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
                 ) : isNum ? (
                     <ValueInput
                         label={undefined}
-                        value={config[field.name] != null ? Number(config[field.name]) : null}
+                        // Storage is RAW; render the DISPLAY value so
+                        // operator sees the units they configured. The
+                        // change handler runs the inverse before
+                        // committing back to storage.
+                        value={config[field.name] != null
+                            ? Number(rawToDisplay(Number(config[field.name]), field.scale))
+                            : null}
                         onValueChanged={(val) => handleFieldChange(field, val)}
                         className={!valid ? 'p-invalid' : ''}
                     />

package/src/components/tis/useRawCycleData.ts

@@ -11,12 +11,27 @@
  *                          (set `enabled` to false to short-circuit while
  *                          a cycle_scatter view is active).
  *
- * Keeping the fetch logic in one place means the two components can't
- * drift in how they discover cycles, default to "latest cycle", or
- * unwrap the per-cycle envelope.
+ * Live updates
+ * ------------
+ * The hook subscribes to the `tis.raw_data_added` broadcast and refreshes
+ * the cycle list whenever a new raw blob lands on disk for the matching
+ * (project, method, run, blob). When the operator is already viewing the
+ * latest cycle, the picker advances to the new latest and the chart
+ * re-paints — that's the customer-facing "chart updates each cycle"
+ * behaviour. When the operator has manually pinned an earlier cycle (e.g.
+ * examining cycle 3 while cycle 47 streams in), the picker stays put so
+ * the examination isn't interrupted.
+ *
+ * The hook intentionally suppresses `read_raw` until at least one cycle
+ * is known to be on disk for this slice. Otherwise the server returns
+ * "no raw_data file found" between `tis.start_test` and the first
+ * `add_raw_data` write, and the chart flashes an error overlay during
+ * what's really just "test just started, no data yet" — confusing for
+ * the operator. With the suppression the chart sits empty (or in a
+ * loading state) until the first raw_data_added broadcast arrives.
  */
 
-import { useContext, useEffect, useState } from 'react';
+import { useCallback, useContext, useEffect, useRef, useState } from 'react';
 import { EventEmitterContext } from '../../core/EventEmitterContext';
 import { MessageType } from '../../hub/CommandMessage';
 
@@ -50,7 +65,7 @@ export interface UseRawCycleDataResult {
 
 export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataResult {
     const { projectId, methodId, runId, blobName, enabled } = opts;
-    const { invoke } = useContext(EventEmitterContext);
+    const { invoke, subscribe, unsubscribe } = useContext(EventEmitterContext);
 
     const [cycles, setCycles]               = useState<number[]>([]);
     const [selectedCycle, setSelectedCycle] = useState<number | null>(null);
@@ -59,14 +74,49 @@ export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataRe
     const [loading, setLoading]             = useState(false);
     const [error, setError]                 = useState<string | null>(null);
 
+    // Track whether the user has explicitly pinned a cycle. When false,
+    // the live-follow path is free to advance the picker to the newest
+    // cycle as it arrives. Flipping to true on a manual pick freezes
+    // the picker so examining cycle 3 while cycle 47 streams in doesn't
+    // get yanked back to 47.
+    //
+    // Lives in a ref so updating it doesn't re-trigger any effect — it's
+    // a behavioural latch, not state the renderer cares about.
+    const userPinnedRef = useRef<boolean>(false);
+
+    /** Discover the per-cycle indices currently on disk for this slice.
+     *  Returns the sorted-ascending list; never throws (a listing error
+     *  is logged-as-empty rather than surfaced — the rendering layer
+     *  has its own empty state). */
+    const listCycles = useCallback(async (): Promise<number[]> => {
+        if (!projectId || !methodId || !runId) return [];
+        try {
+            const resp: any = await invoke(
+                'tis.list_raw' as any, MessageType.Request as any,
+                { project_id: projectId, method_id: methodId, run_id: runId } as any,
+            );
+            if (!resp?.success) return [];
+            const list: any[] = resp.data?.cycles ?? [];
+            return list
+                .filter(c => c?.name === blobName && typeof c?.cycle_index === 'number')
+                .map(c => c.cycle_index as number)
+                .sort((a, b) => a - b);
+        } catch {
+            return [];
+        }
+    }, [projectId, methodId, runId, blobName, invoke]);
+
     // Reset cycle state when the run identity (or blob) changes — the
     // new slice has its own cycle list and its own "latest" target.
+    // Clearing userPinnedRef too so the next slice is free to follow
+    // the latest cycle automatically.
     useEffect(() => {
         setCycles([]);
         setSelectedCycle(null);
         setRaw(null);
         setEnvelope(null);
         setError(null);
+        userPinnedRef.current = false;
     }, [projectId, methodId, runId, blobName]);
 
     // Cycle-list discovery. Runs ahead of the data fetch so the cycle
@@ -75,47 +125,86 @@ export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataRe
         if (!enabled || !projectId || !methodId || !runId) return;
         let cancelled = false;
         (async () => {
-            try {
-                const resp: any = await invoke(
-                    'tis.list_raw' as any, MessageType.Request as any,
-                    { project_id: projectId, method_id: methodId, run_id: runId } as any,
-                );
-                if (cancelled || !resp?.success) return;
-                const list: any[] = resp.data?.cycles ?? [];
-                const indices = list
-                    .filter(c => c?.name === blobName && typeof c?.cycle_index === 'number')
-                    .map(c => c.cycle_index as number)
-                    .sort((a, b) => a - b);
-                setCycles(indices);
-                if (indices.length > 0) {
-                    setSelectedCycle(prev => prev ?? indices[indices.length - 1]);
-                }
-            } catch {
-                // Listing failure is non-fatal — the data fetch below
-                // still tries "latest" and the picker just stays empty.
+            const indices = await listCycles();
+            if (cancelled) return;
+            setCycles(indices);
+            if (indices.length > 0) {
+                setSelectedCycle(prev => prev ?? indices[indices.length - 1]);
             }
         })();
         return () => { cancelled = true; };
-    }, [enabled, projectId, methodId, runId, blobName, invoke]);
+    }, [enabled, projectId, methodId, runId, blobName, listCycles]);
+
+    // Live updates: each new raw_data file landing on disk triggers a
+    // re-listing. The handler closes over `selectedCycle` via the
+    // functional setter and the live `cycles` snapshot, so we use refs
+    // to avoid re-subscribing every time those state values change.
+    const cyclesRef = useRef<number[]>(cycles);
+    cyclesRef.current = cycles;
+    const selectedRef = useRef<number | null>(selectedCycle);
+    selectedRef.current = selectedCycle;
+
+    useEffect(() => {
+        if (!enabled || !projectId || !methodId || !runId) return;
+        const onRawAdded = async (payload: any) => {
+            // Filter to the slice this hook instance is bound to.
+            // The server can also fire raw_data_added for the same
+            // run+method+project but a different blob name (rare, but
+            // legal); the blob-name check keeps us from refreshing
+            // for an unrelated dataset.
+            if (payload?.project_id !== projectId) return;
+            if (payload?.method_id  !== methodId)  return;
+            if (payload?.run_id     !== runId)     return;
+            if (payload?.name       !== blobName)  return;
+
+            const fresh = await listCycles();
+            if (fresh.length === 0) return;
+            setCycles(fresh);
+            // Auto-follow "latest" iff the operator hasn't manually
+            // moved away from it. The "was viewing the previous
+            // latest" check uses the snapshot taken via the ref so the
+            // closure stays stable.
+            const prevLatest = cyclesRef.current.length > 0
+                ? cyclesRef.current[cyclesRef.current.length - 1]
+                : null;
+            const newLatest  = fresh[fresh.length - 1];
+            const onLatest   = !userPinnedRef.current
+                && (selectedRef.current === null || selectedRef.current === prevLatest);
+            if (onLatest && newLatest !== selectedRef.current) {
+                setSelectedCycle(newLatest);
+            }
+        };
+        const id = subscribe('tis.raw_data_added', onRawAdded);
+        return () => { unsubscribe(id); };
+    }, [enabled, projectId, methodId, runId, blobName, listCycles, subscribe, unsubscribe]);
 
     // Lazy blob fetch — runs whenever identifiers / selectedCycle change.
+    // Suppressed entirely when no cycle is selected (e.g. test just
+    // started, no raw_data on disk yet): no point asking the server
+    // for a file that's known to not exist, and surfacing the resulting
+    // error would flash an unfriendly overlay over an otherwise valid
+    // "waiting for data" state.
     useEffect(() => {
         if (!enabled || !projectId || !methodId || !runId) {
             setRaw(null); setEnvelope(null); setLoading(false); setError(null);
             return;
         }
+        if (selectedCycle == null) {
+            setRaw(null); setEnvelope(null); setLoading(false); setError(null);
+            return;
+        }
         let cancelled = false;
         setLoading(true);
         setError(null);
         (async () => {
             try {
-                const args: Record<string, any> = {
-                    project_id: projectId, method_id: methodId,
-                    run_id: runId, name: blobName,
-                };
-                if (selectedCycle != null) args.cycle_index = selectedCycle;
                 const resp: any = await invoke(
-                    'tis.read_raw' as any, MessageType.Request as any, args as any,
+                    'tis.read_raw' as any, MessageType.Request as any,
+                    {
+                        project_id: projectId, method_id: methodId,
+                        run_id: runId, name: blobName,
+                        cycle_index: selectedCycle,
+                    } as any,
                 );
                 if (cancelled) return;
                 if (resp?.success) {
@@ -134,7 +223,19 @@ export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataRe
         return () => { cancelled = true; };
     }, [enabled, projectId, methodId, runId, blobName, selectedCycle, invoke]);
 
-    return { cycles, selectedCycle, setSelectedCycle, raw, envelope, loading, error };
+    // Public setter wraps setSelectedCycle and flips userPinnedRef so
+    // an operator's manual pick freezes the picker for the rest of the
+    // run. Re-mounting (new run) clears userPinnedRef in the
+    // identifier-change effect above.
+    const pickCycle = useCallback((n: number | null) => {
+        userPinnedRef.current = n != null;
+        setSelectedCycle(n);
+    }, []);
+
+    return {
+        cycles, selectedCycle, setSelectedCycle: pickCycle,
+        raw, envelope, loading, error,
+    };
 }
 
 /**