@adcops/autocore-react 3.3.79 → 3.3.83

package/src/components/tis/TestRawDataView.tsx

@@ -10,7 +10,7 @@
  * built-in dialog inside <TestDataView>.
  */
 
-import React, { useContext, useEffect, useMemo, useRef, useState } from 'react';
+import React, { useMemo, useRef, useState } from 'react';
 import { Button } from 'primereact/button';
 import { Dropdown } from 'primereact/dropdown';
 
@@ -21,10 +21,9 @@ import { Chart as ChartJS,
 import zoomPlugin from 'chartjs-plugin-zoom';
 import { Line } from 'react-chartjs-2';
 
-import { EventEmitterContext } from '../../core/EventEmitterContext';
-import { MessageType } from '../../hub/CommandMessage';
 import type { ChartView, TestMethod } from './TestDataView';
 import { useTis } from './TisProvider';
+import { useRawCycleData } from './useRawCycleData';
 
 ChartJS.register(
     CategoryScale, LinearScale, PointElement, LineElement,
@@ -53,19 +52,8 @@ export const TestRawDataView: React.FC<TestRawDataViewProps> = (props) => {
     const runId     = props.runId     ?? tis.selection.runId;
     const schema    = props.schema    ?? (methodId ? (tis.schemas[methodId] as TestMethod) : undefined);
     const { blobName, chartHeight = '60vh' } = props;
-    const { invoke } = useContext(EventEmitterContext);
-
-    const [raw, setRaw]         = useState<Record<string, number[]> | null>(null);
-    const [envelope, setEnvelope] = useState<any | null>(null);
-    const [loading, setLoading] = useState(true);
-    const [error, setError]     = useState<string | null>(null);
     const chartRef              = useRef<any>(null);
 
-    // Per-test cycle picker. Default to latest cycle on disk; the
-    // operator can flip backward through earlier cycles.
-    const [cycles, setCycles]               = useState<number[]>([]);
-    const [selectedCycle, setSelectedCycle] = useState<number | null>(null);
-
     // raw_trace-capable views only — cycle scatter lives in <TestDataView>.
     const traceViews = useMemo(() => {
         const out: { name: string; view: ChartView }[] = [];
@@ -81,75 +69,19 @@ export const TestRawDataView: React.FC<TestRawDataViewProps> = (props) => {
 
     const effectiveBlobName = blobName ?? schema?.raw_data?.blob_name ?? 'trace';
 
-    // Reset cycle state when the run identity changes; the new run has
-    // its own cycle list and "latest" target.
-    useEffect(() => {
-        setCycles([]);
-        setSelectedCycle(null);
-    }, [projectId, methodId, runId, effectiveBlobName]);
-
-    // Discover available cycles for this run/blob. Runs ahead of the
-    // data fetch so the cycle picker can render immediately.
-    useEffect(() => {
-        if (!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 === effectiveBlobName && 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.
-            }
-        })();
-        return () => { cancelled = true; };
-    }, [projectId, methodId, runId, effectiveBlobName, invoke]);
-
-    // Lazy fetch — runs on mount / when identifiers / selectedCycle change.
-    useEffect(() => {
-        if (!projectId || !methodId || !runId) {
-            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: effectiveBlobName,
-                };
-                if (selectedCycle != null) args.cycle_index = selectedCycle;
-                const resp: any = await invoke(
-                    'tis.read_raw' as any, MessageType.Request as any, args as any);
-                if (cancelled) return;
-                if (resp?.success) {
-                    const payload = resp.data ?? {};
-                    setEnvelope(payload);
-                    setRaw(unwrapEnvelope(payload));
-                } else {
-                    setError(resp?.error_message ?? 'Failed to read raw data');
-                }
-            } catch (e: any) {
-                if (!cancelled) setError(String(e?.message ?? e));
-            } finally {
-                if (!cancelled) setLoading(false);
-            }
-        })();
-        return () => { cancelled = true; };
-    }, [projectId, methodId, runId, effectiveBlobName, selectedCycle, invoke]);
+    // Cycle discovery + per-cycle blob fetch live in the shared hook so
+    // <TestDataView>'s unified panel can reuse the exact same fetch path
+    // when a raw_trace view is selected there.
+    const { cycles, selectedCycle, setSelectedCycle, raw, envelope, loading, error } =
+        useRawCycleData({
+            projectId, methodId, runId,
+            blobName: effectiveBlobName,
+            // This component only renders raw_trace charts, so always
+            // fetch as long as the run identity is in scope. The early
+            // returns below cover the "no test selected" / "no schema"
+            // cases that would otherwise be wasted requests.
+            enabled: !!projectId && !!methodId && !!runId,
+        });
 
     const chartData = useMemo(() => {
         if (!raw || !selectedView) return null;
@@ -279,20 +211,6 @@ const EmptyState: React.FC<{ message: string }> = ({ message }) => (
     <div style={{ padding: '1rem', color: 'var(--text-secondary-color)' }}>{message}</div>
 );
 
-// tis.read_raw returns one of:
-//   - per-cycle envelope: { cycle_index, cycle_fields, context, data }
-//   - legacy flat blob:   { col: number[] }
-// Chart/CSV code only wants the columnar payload — strip the envelope
-// when present, otherwise pass the blob through.
-const unwrapEnvelope = (blob: any): Record<string, number[]> => {
-    if (!blob || typeof blob !== 'object') return {};
-    if ('data' in blob && blob.data && typeof blob.data === 'object'
-        && Object.values(blob.data).some(v => Array.isArray(v))) {
-        return blob.data;
-    }
-    return blob;
-};
-
 // Strip of cycle_index + cycle_fields + context, rendered above the
 // chart so the operator can see *which* cycle they're looking at and
 // what schema-declared metric values were active for it. Renders

package/src/components/tis/TestSetupForm.tsx

@@ -368,19 +368,35 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
     };
 
     /**
-     * If the test method has an `asset_ref` whose `select=by_id_field`
-     * pulls from this config field, return the asset_type the field
-     * should pick from. The form renders that field as a dropdown of
-     * AMS assets instead of a free-form text input.
+     * If any `asset_ref` declares `select=by_id_field` with
+     * `from: "config.<field_name>"` for this field, return the
+     * asset_type the field should pick from. The form renders that
+     * field as a dropdown of AMS assets instead of a free-form text
+     * input.
      *
-     * The schema already encodes the relationship via `from:
-     * "config.<field_name>"` — no project.json change required.
+     * Refs are sourced from two places, matching what the server's
+     * resolver does at stage time:
+     *   1. Method-level (`schema.asset_refs`) — method-specific
+     *      accessories.
+     *   2. Project-level (`tis.projectAssetRefs`) — system hardware
+     *      that applies to every test method (e.g. the test surface
+     *      picked per-test by id).
+     * Method-level wins on `field`-name collision, so a method can
+     * override the project default.
      */
     const assetTypeForField = (field: TestFieldDef): string | null => {
-        const refs = (schema?.asset_refs ?? []) as TisAssetRef[];
+        const methodRefs  = (schema?.asset_refs ?? []) as TisAssetRef[];
+        const projectRefs = (tis.projectAssetRefs ?? []) as TisAssetRef[];
         const expectedFrom = `config.${field.name}`;
-        const hit = refs.find(r => r.select === 'by_id_field' && r.from === expectedFrom);
-        return hit ? hit.asset_type : null;
+        // Method wins on collision — iterate method refs first.
+        const methodHit = methodRefs.find(
+            r => r.select === 'by_id_field' && r.from === expectedFrom,
+        );
+        if (methodHit) return methodHit.asset_type;
+        const projectHit = projectRefs.find(
+            r => r.select === 'by_id_field' && r.from === expectedFrom,
+        );
+        return projectHit ? projectHit.asset_type : null;
     };
 
     const renderConfigField = (field: TestFieldDef) => {

package/src/components/tis/TisProvider.tsx

@@ -91,8 +91,33 @@ export interface TisRunCacheEntry {
     rawData: { [blobName: string]: any };
 }
 
+/**
+ * One project-level asset_ref entry, in the wire shape returned by
+ * `tis.list_schemas`. Mirrors `Project.asset_refs` on the server.
+ * Carries only the fields the form's by_id_field lookup needs;
+ * other fields (label, description, calibration_required) are
+ * ignored but pass through untouched.
+ */
+export interface TisProjectAssetRef {
+    field: string;
+    asset_type: string;
+    select: 'by_location' | 'by_id_field';
+    /** Set when `select=by_id_field` — the dotted config path
+     *  (`config.<field_name>`) whose value picks the asset. */
+    from?: string;
+    /** Set when `select=by_location` — the role/location key. */
+    location?: string;
+}
+
 export interface TisContextValue {
     schemas: SchemaRegistry;
+    /** Project-level asset_refs from `tis.list_schemas`. Empty array
+     *  when the project declares none. The HMI form merges these with
+     *  the active method's own `asset_refs` before deciding whether to
+     *  render a config field as a dropdown (by_id_field) or a free-form
+     *  input. Method-level refs win on `field`-name collision, mirroring
+     *  the server resolver. */
+    projectAssetRefs: TisProjectAssetRef[];
     defaultMethodId: string;
     schemasLoaded: boolean;
 
@@ -182,6 +207,7 @@ const EMPTY_SELECTION: TisSelection = {
 
 const TisContext = createContext<TisContextValue>({
     schemas: {},
+    projectAssetRefs: [],
     defaultMethodId: '',
     schemasLoaded: false,
     state: EMPTY_STATE,
@@ -252,6 +278,7 @@ export const TisProvider: React.FC<TisProviderProps> = ({ children, defaultMetho
     const { invoke, subscribe, unsubscribe } = useContext(EventEmitterContext);
 
     const [schemas, setSchemas] = useState<SchemaRegistry>({});
+    const [projectAssetRefs, setProjectAssetRefs] = useState<TisProjectAssetRef[]>([]);
     const [defaultMethodId, setDefaultMethodId] = useState<string>(initialDefault ?? '');
     const [schemasLoaded, setSchemasLoaded] = useState(false);
 
@@ -284,7 +311,11 @@ export const TisProvider: React.FC<TisProviderProps> = ({ children, defaultMetho
                 if (resp?.success && resp.data) {
                     const methods = (resp.data.test_methods ?? {}) as SchemaRegistry;
                     const dflt    = (resp.data.default_method_id ?? '') as string;
+                    const refs    = Array.isArray(resp.data.asset_refs)
+                        ? (resp.data.asset_refs as TisProjectAssetRef[])
+                        : [];
                     setSchemas(methods);
+                    setProjectAssetRefs(refs);
                     if (!initialDefault && dflt) setDefaultMethodId(dflt);
                     setSchemasLoaded(true);
                 } else {
@@ -620,14 +651,14 @@ export const TisProvider: React.FC<TisProviderProps> = ({ children, defaultMetho
     }, []);
 
     const value: TisContextValue = useMemo(() => ({
-        schemas, defaultMethodId, schemasLoaded,
+        schemas, projectAssetRefs, defaultMethodId, schemasLoaded,
         state, selection, setSelection,
         existingProjects, projectKnown, refreshProjects, markProjectJustCreated,
         projectFields, projectFieldsLoaded, loadProjectFields, setProjectFields,
         stagedConfig, setStagedConfig, clearStagedConfig,
         fetchRuns, fetchRun, runCache,
     }), [
-        schemas, defaultMethodId, schemasLoaded,
+        schemas, projectAssetRefs, defaultMethodId, schemasLoaded,
         state, selection, setSelection,
         existingProjects, projectKnown, refreshProjects, markProjectJustCreated,
         projectFields, projectFieldsLoaded, loadProjectFields, setProjectFields,

package/src/components/tis/useRawCycleData.ts

@@ -0,0 +1,157 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * useRawCycleData — shared hook that fetches `tis.list_raw` + `tis.read_raw`
+ * for one (project, method, run, blob_name) slice and tracks the
+ * operator's per-cycle selection. Used by:
+ *
+ *   - <TestRawDataView> — the focused trace-only viewer.
+ *   - <TestDataView>    — the unified chart panel, which lazily fetches
+ *                          raw data only when a raw_trace view is selected
+ *                          (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.
+ */
+
+import { useContext, useEffect, useState } from 'react';
+import { EventEmitterContext } from '../../core/EventEmitterContext';
+import { MessageType } from '../../hub/CommandMessage';
+
+export interface UseRawCycleDataOptions {
+    projectId?: string;
+    methodId?:  string;
+    runId?:     string;
+    /** Blob name (e.g. "trace"); usually schema.raw_data.blob_name. */
+    blobName:   string;
+    /** When false, the hook does no fetching and returns empty state.
+     *  Wire to "is the current chart view a raw_trace?" so scatter
+     *  selections don't trigger a blob round-trip. */
+    enabled:    boolean;
+}
+
+export interface UseRawCycleDataResult {
+    /** Per-cycle indices discovered on disk for this run/blob, sorted
+     *  ascending. Empty when no raw_data has been written yet. */
+    cycles:           number[];
+    selectedCycle:    number | null;
+    setSelectedCycle: (n: number | null) => void;
+    /** Columnar payload unwrapped from the per-cycle envelope, or the
+     *  blob itself for legacy flat shapes. `null` until the fetch lands. */
+    raw:              Record<string, number[]> | null;
+    /** Full envelope as returned by `tis.read_raw`. Carries
+     *  `cycle_index`, `cycle_fields`, and `context` alongside `data`. */
+    envelope:         any | null;
+    loading:          boolean;
+    error:            string | null;
+}
+
+export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataResult {
+    const { projectId, methodId, runId, blobName, enabled } = opts;
+    const { invoke } = useContext(EventEmitterContext);
+
+    const [cycles, setCycles]               = useState<number[]>([]);
+    const [selectedCycle, setSelectedCycle] = useState<number | null>(null);
+    const [raw, setRaw]                     = useState<Record<string, number[]> | null>(null);
+    const [envelope, setEnvelope]           = useState<any | null>(null);
+    const [loading, setLoading]             = useState(false);
+    const [error, setError]                 = useState<string | null>(null);
+
+    // Reset cycle state when the run identity (or blob) changes — the
+    // new slice has its own cycle list and its own "latest" target.
+    useEffect(() => {
+        setCycles([]);
+        setSelectedCycle(null);
+        setRaw(null);
+        setEnvelope(null);
+        setError(null);
+    }, [projectId, methodId, runId, blobName]);
+
+    // Cycle-list discovery. Runs ahead of the data fetch so the cycle
+    // picker can render immediately. Filtered to the requested blob name.
+    useEffect(() => {
+        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.
+            }
+        })();
+        return () => { cancelled = true; };
+    }, [enabled, projectId, methodId, runId, blobName, invoke]);
+
+    // Lazy blob fetch — runs whenever identifiers / selectedCycle change.
+    useEffect(() => {
+        if (!enabled || !projectId || !methodId || !runId) {
+            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,
+                );
+                if (cancelled) return;
+                if (resp?.success) {
+                    const payload = resp.data ?? {};
+                    setEnvelope(payload);
+                    setRaw(unwrapEnvelope(payload));
+                } else {
+                    setError(resp?.error_message ?? 'Failed to read raw data');
+                }
+            } catch (e: any) {
+                if (!cancelled) setError(String(e?.message ?? e));
+            } finally {
+                if (!cancelled) setLoading(false);
+            }
+        })();
+        return () => { cancelled = true; };
+    }, [enabled, projectId, methodId, runId, blobName, selectedCycle, invoke]);
+
+    return { cycles, selectedCycle, setSelectedCycle, raw, envelope, loading, error };
+}
+
+/**
+ * `tis.read_raw` returns one of:
+ *   - per-cycle envelope: `{ cycle_index, cycle_fields, context, data: { col: number[] } }`
+ *   - legacy flat blob:   `{ col: number[] }`
+ *
+ * Chart and CSV code only care about the columnar payload — peel off
+ * the envelope when present, otherwise pass the blob through. Returned
+ * shape is always `Record<string, number[]>` so consumers can index
+ * uniformly.
+ */
+export function unwrapEnvelope(blob: any): Record<string, number[]> {
+    if (!blob || typeof blob !== 'object') return {};
+    if ('data' in blob && blob.data && typeof blob.data === 'object'
+        && Object.values(blob.data).some(v => Array.isArray(v))) {
+        return blob.data;
+    }
+    return blob;
+}