@adcops/autocore-react 3.3.113 → 3.3.116

package/src/components/tis/TestDataView.tsx

@@ -72,6 +72,12 @@ export interface TestFieldDef {
      *  (label === stored value) or an explicit { label, value } pair.
      *  Mirrors the Rust TestField::options (untagged FieldOption). */
     options?: Array<string | number | boolean | { label: string; value: any }>;
+    /** Operator-editable after recording — annotation columns only (a specimen
+     *  or lot id noted against a captured row). Meaningful on `cycle_fields`;
+     *  the server refuses `tis.update_cycle` for any field without it, so
+     *  measured columns can never be typed over. Mirrors Rust
+     *  `TestField::editable`. */
+    editable?: boolean;
 }
 
 export interface ChartAxis  { field?: string; column?: string; label?: string; }
@@ -155,10 +161,20 @@ export interface TestConfiguration {
     defaults?: { [field: string]: any };
 }
 export interface TestMethod {
-    project_fields:  TestFieldDef[];
-    config_fields:   TestFieldDef[];
-    cycle_fields:    TestFieldDef[];
-    results_fields:  TestFieldDef[];
+    /* All four field lists are OPTIONAL by design. Server-side each is
+     * `#[serde(default)]`, so a method that declares only `config_fields` is
+     * perfectly valid and the other keys simply aren't in the JSON. Typing
+     * them as required let `schema.cycle_fields.map(...)` compile and then
+     * blank the operator's page at runtime (gen4_ac, 2026-08-11). Keep them
+     * optional so the compiler demands a `?? []` at every use. */
+    project_fields?: TestFieldDef[];
+    config_fields?:  TestFieldDef[];
+    /** Operator-entered per-row annotation. Recorded onto each cycle row
+     *  by the server and rendered as the first Cycle Data columns after
+     *  the row index, in declared order. */
+    cycle_config_fields?: TestFieldDef[];
+    cycle_fields?:   TestFieldDef[];
+    results_fields?: TestFieldDef[];
     raw_data?:       RawDataShape | null;
     views?:          { [name: string]: ChartView };
     /** Optional pretty label for the Test Method picker. */
@@ -208,6 +224,46 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
     const [rawOpen, setRawOpen] = useState(false);
     const [configOpen, setConfigOpen] = useState(false);
 
+    /**
+     * Commit an operator edit to an annotation cell (`tis.update_cycle`).
+     *
+     * The server is the gate: it accepts a field only if the method declares it
+     * `editable: true`, so a measured column is refused even if a caller asks.
+     * We update local state only after the round trip succeeds — showing an edit
+     * that didn't persist is worse than showing the old value.
+     */
+    const saveCycleField = useCallback(
+        async (row: any, field: string, value: any) => {
+            const cycleIndex = row?.cycle_index;
+            if (!projectId || !methodId || !runId || !cycleIndex) return;
+            try {
+                const resp: any = await invoke(
+                    'tis.update_cycle' as any,
+                    MessageType.Request,
+                    {
+                        project_id: projectId,
+                        method_id: methodId,
+                        run_id: runId,
+                        cycle_index: cycleIndex,
+                        fields: { [field]: value },
+                    } as any,
+                );
+                if (resp?.success === false) {
+                    console.error('tis.update_cycle rejected:', resp?.error_message);
+                    return;
+                }
+                setCycles((prev) =>
+                    prev.map((c) =>
+                        c?.cycle_index === cycleIndex ? { ...c, [field]: value } : c,
+                    ),
+                );
+            } catch (e) {
+                console.error('tis.update_cycle failed:', e);
+            }
+        },
+        [invoke, projectId, methodId, runId],
+    );
+
     // Direct handle on the chart.js instance so the toolbar's reset-
     // zoom button can call chart.resetZoom() — the zoom plugin's only
     // imperative API. Customers like the wheel/pinch/drag zoom but
@@ -742,12 +798,30 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
                 doesn't render 1000 row elements at once. */}
             {(() => {
                 const useVirtual = cycles.length > CYCLE_VIRTUAL_THRESHOLD;
-                const cycleColumns: ScienceColumn[] = schema.cycle_fields.map(f => ({
+                // `?? []` is load-bearing: cycle_fields is `#[serde(default)]`
+                // server-side, so a method that declares only config_fields is
+                // valid and arrives with the key absent. Without the guard the
+                // `.map` throws inside render and React unmounts the whole
+                // app — the operator sees a blank page, not a missing table.
+                // Operator-entered annotation leads, right after the row
+                // index, then the measured columns — the same order the
+                // server writes into every CSV export. Annotation columns
+                // are always editable: they're the operator's own note, so
+                // correcting a mistyped one is the intended workflow (the
+                // server accepts cycle_config_fields on tis.update_cycle
+                // without an `editable` flag), while measured columns still
+                // have to opt in.
+                const toColumn = (f: TestFieldDef, editable: boolean): ScienceColumn => ({
                     field: f.name,
                     label: f.name,
                     units: f.units,
+                    editable,
                     body: (row) => formatCell(row[f.name], f.type, f.scale),
-                }));
+                });
+                const cycleColumns: ScienceColumn[] = [
+                    ...(schema.cycle_config_fields ?? []).map(f => toColumn(f, true)),
+                    ...(schema.cycle_fields ?? []).map(f => toColumn(f, !!f.editable)),
+                ];
                 return (
                     <ScienceTable
                         title={`Cycle Data (${cycles.length})`}
@@ -756,6 +830,7 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
                         scrollable={useVirtual}
                         scrollHeight={useVirtual ? cycleTableHeight : undefined}
                         emptyMessage="No cycles yet."
+                        onCellEdit={saveCycleField}
                     />
                 );
             })()}
@@ -767,7 +842,7 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
             {(() => {
                 const values = { ...results, ...sampleSummary };
                 const hasValues = Object.keys(values).length > 0;
-                const resultColumns: ScienceColumn[] = schema.results_fields.map(f => ({
+                const resultColumns: ScienceColumn[] = (schema.results_fields ?? []).map(f => ({
                     field: f.name,
                     label: f.name,
                     units: f.units,

package/src/components/tis/TestFieldRow.tsx

@@ -0,0 +1,297 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * The one place a TIS `TestField` becomes an input.
+ *
+ * Test Configuration (<TestSetupForm>, per-test) and Cycle Configuration
+ * (<CycleConfigForm>, per-row) render the same declarative field schema
+ * with the same display/raw unit convention, the same emptiness and range
+ * rules, and the same 4-column `ac-form-grid` row shape. They differ only
+ * in where the value is stored and when it is committed, so the rendering
+ * and the validation rules live here and both forms call in.
+ *
+ * Storage is always RAW; `scale` converts only at the boundary:
+ *   display = raw * scale     raw = display / scale
+ */
+
+import React from 'react';
+import { Button } from 'primereact/button';
+import { Dropdown } from 'primereact/dropdown';
+import { ValueInput } from '../ValueInput';
+import { TextInput } from '../TextInput';
+
+/**
+ * One field in a test method's schema. Mirrors the Rust `TestField`
+ * (autocore-ams `config.rs`) — the same shape backs project_fields,
+ * config_fields, cycle_config_fields, cycle_fields and results_fields.
+ */
+export interface TestFieldDef {
+    /** Canonical key — wire format, generated code, on-disk JSON. */
+    name: string;
+    type: string;
+    units?: string;
+    required?: boolean;
+    source?: string;
+    /** Pretty label rendered by the form. Falls back to `name`. Units
+     *  are appended automatically; don't pre-format `[mm]` into label. */
+    label?: string;
+    /** Long-form guidance surfaced as a hover tooltip on an info icon. */
+    description?: string;
+    /** Seed value applied when the operator selects this test method.
+     *  For source-bound fields the default is written to the GM tag so
+     *  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. **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;
+    /** Optional inclusive bounds (display units, same convention as `default`
+     *  and `scale`) for the operator's numeric entry. The numeric input
+     *  rejects values outside `[min, max]`; non-numeric fields ignore them. */
+    min?: number;
+    max?: number;
+    /** Optional fixed set of choices. When present, the field renders
+     *  as a dropdown and the operator must pick one of the declared
+     *  values rather than typing freely. Each entry is either a bare
+     *  scalar (label === value) or an explicit `{ label, value }` pair
+     *  when the displayed text should differ from the stored value.
+     *  Works with any `type`; like `default`, values are authored in
+     *  display units when `scale` is set. */
+    options?: Array<
+        | string
+        | number
+        | boolean
+        | { label?: string; value: string | number | boolean }
+    >;
+    /** Operator-editable after recording. Meaningful on `cycle_fields`;
+     *  `cycle_config_fields` are always editable (they're annotation, not
+     *  measurement) and don't need the flag. */
+    editable?: boolean;
+    /** `cycle_config_fields` only: clear this entry once a row has recorded
+     *  it, so the next row can't silently inherit a stale annotation. Fires
+     *  at the method's `cycle_config_scope` boundary. */
+    autoclear?: boolean;
+}
+
+/**
+ * Which boundary an operator annotates `cycle_config_fields` at. Mirrors
+ * the Rust `CycleConfigScope`.
+ *
+ *   `'run'`    one latch per Start — the same values stamp every cycle of
+ *              the run and clear when it closes. Default, and the only
+ *              correct choice for a machine that records many cycles from
+ *              one Start.
+ *   `'cycle'`  one latch per cycle — values clear after each recorded row
+ *              and the gate re-arms, so the operator annotates every one.
+ */
+export type CycleConfigScope = 'run' | 'cycle';
+
+// -------------------------------------------------------------------------
+// Display ↔ raw boundary
+// -------------------------------------------------------------------------
+
+/**
+ * Convention: `display = raw * scale`, `raw = display / scale`. Matches
+ * AutoCoreTagContext. Default scale = 1.0 (no conversion). Non-numeric
+ * values (string, null, undefined, NaN) pass through unchanged — the
+ * forms share one change handler across fields of every type.
+ *
+ * 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, so scales can change in project.json without
+ * invalidating historical records.
+ */
+export 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;
+};
+
+export 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;
+};
+
+/** Field label with `[units]` appended when declared. */
+export const labelOf = (f: TestFieldDef): string => {
+    const base = f.label && f.label.length > 0 ? f.label : f.name;
+    return f.units ? `${base} [${f.units}]` : base;
+};
+
+export const hasDescription = (f: TestFieldDef): boolean =>
+    typeof f.description === 'string' && f.description.length > 0;
+
+/**
+ * "Not entered." Mirrors the server's `cycle_config_value_is_empty`
+ * (autocore-tis `config.rs`) so the HMI gate and the GM gate can never
+ * disagree about whether a field is filled in: absent, null, or an
+ * empty/whitespace string. Numeric zero and `false` are entries.
+ */
+export const fieldValueIsEmpty = (v: any): boolean =>
+    v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
+
+/**
+ * Range check for a numeric field's stored RAW value against its declared
+ * `min`/`max` (authored in DISPLAY units). Returns a short human-readable
+ * reason ("must be ≥ 5") when out of range, or null when in range / not
+ * applicable (empty value, no bounds, or non-numeric).
+ */
+export const rangeIssue = (f: TestFieldDef, raw: any): string | null => {
+    if (fieldValueIsEmpty(raw) || raw === '') return null;
+    if (f.min == null && f.max == null) return null;
+    const disp = Number(rawToDisplay(Number(raw), f.scale));
+    if (!Number.isFinite(disp)) return null;
+    // Bounds form an unordered interval — an author may write the range in
+    // magnitude order (min:-50, max:-1000), which is numerically inverted.
+    const lo = f.min != null && f.max != null ? Math.min(f.min, f.max) : f.min;
+    const hi = f.min != null && f.max != null ? Math.max(f.min, f.max) : f.max;
+    if (lo != null && disp < lo) return `must be ≥ ${lo}`;
+    if (hi != null && disp > hi) return `must be ≤ ${hi}`;
+    return null;
+};
+
+/**
+ * The single validity rule for an operator-entered field: required-and-empty,
+ * or out of range. Returns a human-readable reason, or null when the value
+ * is acceptable. Both forms build their issue lists and their per-field red
+ * markers from this, so the summary dialog and the field icons always agree.
+ */
+export const fieldIssue = (f: TestFieldDef, raw: any): string | null => {
+    if (f.required && fieldValueIsEmpty(raw)) return 'is required';
+    return rangeIssue(f, raw);
+};
+
+export const fieldIsValid = (f: TestFieldDef, raw: any): boolean =>
+    fieldIssue(f, raw) === null;
+
+/**
+ * Normalise a field's `options` (bare scalars and/or `{label, value}`
+ * pairs) into the `{ label, value }[]` shape PrimeReact's Dropdown wants.
+ * Bare scalars use their stringified form as the label.
+ */
+export const normalizeOptions = (
+    opts: TestFieldDef['options'],
+): { label: string; value: string | number | boolean }[] =>
+    (opts ?? []).map((o) =>
+        o !== null && typeof o === 'object'
+            ? { label: String(o.label ?? o.value), value: o.value }
+            : { label: String(o), value: o },
+    );
+
+// -------------------------------------------------------------------------
+// Rendering
+// -------------------------------------------------------------------------
+
+export interface TestFieldRowProps {
+    field: TestFieldDef;
+    /** Stored RAW value. */
+    value: any;
+    /** Receives the RAW value (the row converts from display for you). */
+    onChange: (raw: any) => void;
+    /** Marks the control invalid. Defaults to `fieldIsValid(field, value)`. */
+    valid?: boolean;
+    /** Read-only rendering — used while a cycle is in flight and its
+     *  annotation is already latched. */
+    disabled?: boolean;
+    /**
+     * Replaces the schema-derived input for this field. Used by
+     * <TestSetupForm> for config fields an AMS `asset_ref` claims, where
+     * the picker is sourced from the asset registry rather than the field
+     * declaration.
+     */
+    control?: React.ReactNode;
+    /** Opens the host form's shared info dialog. When omitted, fields with
+     *  a `description` render no info affordance. */
+    onInfo?: (field: TestFieldDef) => void;
+}
+
+/**
+ * One row of a 4-column `ac-form-grid`: label, control, info button,
+ * validity icon. Returns a Fragment, so the caller owns the grid.
+ */
+export const TestFieldRow: React.FC<TestFieldRowProps> = ({
+    field, value, onChange, valid, disabled, control, onInfo,
+}) => {
+    const ok = valid ?? fieldIsValid(field, value);
+    const dropdownOptions = !control && Array.isArray(field.options) && field.options.length > 0
+        ? normalizeOptions(field.options)
+        : null;
+    const isNum = !control && !dropdownOptions
+        && field.type !== 'string' && field.type !== 'bool';
+
+    const input = control ?? (dropdownOptions ? (
+        <Dropdown
+            value={value ?? null}
+            options={dropdownOptions}
+            onChange={(e) => onChange(e.value)}
+            placeholder={`Select ${field.label ?? field.name}…`}
+            className={`ac-dropdown-clearable${!ok ? ' p-invalid' : ''}`}
+            showClear={!field.required}
+            disabled={disabled}
+        />
+    ) : isNum ? (
+        <ValueInput
+            label={undefined}
+            // Storage is RAW; render the DISPLAY value so the operator sees
+            // the units they configured. The change handler runs the inverse
+            // before committing back to storage.
+            value={value != null ? Number(rawToDisplay(Number(value), field.scale)) : null}
+            // min/max are authored in display units, matching the value
+            // rendered above — ValueInput rejects out-of-range entries.
+            min={field.min}
+            max={field.max}
+            onValueChanged={(val) => onChange(displayToRaw(val, field.scale))}
+            className={!ok ? 'p-invalid' : ''}
+            disabled={disabled}
+        />
+    ) : (
+        <TextInput
+            label={undefined}
+            value={value != null ? String(value) : ''}
+            onValueChanged={(val) => onChange(val)}
+            className={!ok ? 'p-invalid' : ''}
+            disabled={disabled}
+        />
+    ));
+
+    return (
+        <React.Fragment>
+            <span className="ac-form-label">{labelOf(field)}</span>
+            {input}
+            {onInfo && hasDescription(field) ? (
+                <Button
+                    icon="pi pi-info-circle"
+                    text
+                    rounded
+                    aria-label={`About ${labelOf(field)}`}
+                    // Replaces a hover Tooltip — touch-friendly. The
+                    // description is shown in the host form's info dialog.
+                    onClick={() => onInfo(field)}
+                />
+            ) : (
+                <span aria-hidden="true" />
+            )}
+            <span style={{
+                color: ok ? 'var(--green-500)' : 'var(--red-500)',
+                display: 'flex',
+                alignItems: 'center',
+            }}>
+                <i className={ok ? 'pi pi-check' : 'pi pi-times'} />
+            </span>
+        </React.Fragment>
+    );
+};