@adcops/autocore-react 3.3.113 → 3.3.116

package/src/components/tis/TestSetupForm.tsx

@@ -6,12 +6,26 @@ import { Dialog } from 'primereact/dialog';
 import { EventEmitterContext } from '../../core/EventEmitterContext';
 import { AutoCoreTagContext } from '../../core/AutoCoreTagContext';
 import { MessageType } from '../../hub/CommandMessage';
-import { ValueInput } from '../ValueInput';
 import { TextInput } from '../TextInput';
 import { useTis } from './TisProvider';
 import { useAmsAssets, useAmsRoles, type AmsAssetEntry } from '../ams/AmsProvider';
 import { TestMethodDialog } from './TestMethodDialog';
 import { ConfigurationDialog, configLabelOf } from './ConfigurationDialog';
+import {
+    TestFieldRow,
+    displayToRaw,
+    fieldIsValid,
+    fieldIssue,
+    labelOf,
+    type CycleConfigScope,
+    type TestFieldDef,
+} from './TestFieldRow';
+
+// The field schema and its display/raw + validation helpers are shared with
+// <CycleConfigForm> — see TestFieldRow.tsx. Re-exported here because this
+// module has been the public home of `TestFieldDef` since before Cycle
+// Configuration existed.
+export type { TestFieldDef } from './TestFieldRow';
 
 /**
  * One asset_ref declared on a test method. We only consume the subset
@@ -27,64 +41,24 @@ interface TisAssetRef {
     location?: string;
 }
 
-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 }
-    >;
-}
-
 export interface TestMethod {
     project_fields: TestFieldDef[];
     config_fields: TestFieldDef[];
     cycle_fields: TestFieldDef[];
     results_fields: TestFieldDef[];
+    /**
+     * Operator-entered per-row annotation, rendered on the Cycle tab by
+     * <CycleConfigForm> rather than by this form. Declared here so a
+     * generated schema literal typechecks against `TestMethod`.
+     */
+    cycle_config_fields?: TestFieldDef[];
+    /** Which boundary the operator annotates at: `'run'` (default — one
+     *  latch per Start, stamping every cycle of the run) or `'cycle'`
+     *  (one latch per cycle, re-gated between cycles). */
+    cycle_config_scope?: CycleConfigScope;
+    /** Open the Cycle Configuration dialog at the boundary instead of
+     *  relying on the operator having filled the Cycle tab. */
+    prompt_before_cycle?: boolean;
     /**
      * AMS asset references resolved at start_test. The form scans these
      * for `select=by_id_field` entries pointing at a config field
@@ -159,38 +133,6 @@ export interface TestSetupFormProps {
 // Helpers
 // -------------------------------------------------------------------------
 
-const labelOf = (f: TestFieldDef): string => {
-    const base = f.label && f.label.length > 0 ? f.label : f.name;
-    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;
-
 /** Matches an FQDN default token like `${gm.safe_speed}` (whole-string). */
 const DEFAULT_TOKEN_RE = /^\$\{\s*([^}]+?)\s*\}$/;
 
@@ -230,41 +172,6 @@ const resolveDefaultRaw = (
     return { raw: displayToRaw(d, field.scale), ok: true };
 };
 
-/**
- * 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). Storage is raw, so we
- * convert to display first to compare against the author's display-unit bounds.
- */
-const rangeIssue = (f: TestFieldDef, raw: any): string | null => {
-    if (raw === undefined || raw === '' || raw === null) 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;
-};
-
-/**
- * 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.
- */
-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 },
-    );
-
 const methodLabelOf = (methodId: string, schema: TestMethod | undefined): string =>
     (schema?.label && schema.label.length > 0) ? schema.label : methodId;
 
@@ -550,10 +457,7 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
 
         for (const field of schema.config_fields) {
             if (field.name === 'sample_id') continue;
-            const v = config[field.name];
-            const empty = v === undefined || v === '' || v === null;
-            if (field.required && empty) { valid = false; break; }
-            if (rangeIssue(field, v)) { valid = false; break; }
+            if (fieldIssue(field, config[field.name])) { valid = false; break; }
         }
 
         setIsValid(valid);
@@ -583,23 +487,15 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
         onValidationChange, invoke,
     ]);
 
-    const isFieldValid = (field: TestFieldDef) => {
-        const v = config[field.name];
-        const empty = v === undefined || v === '' || v === null;
-        if (field.required && empty) return false;
-        if (rangeIssue(field, v)) return false;
-        return true;
-    };
+    const isFieldValid = (field: TestFieldDef) => fieldIsValid(field, config[field.name]);
 
     const handleSampleIdChange = (value: string) => {
         setSampleIdLocal(value);
     };
 
-    const handleFieldChange = async (field: TestFieldDef, val: any) => {
-        // 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);
+    const handleFieldChange = async (field: TestFieldDef, rawVal: any) => {
+        // <TestFieldRow> has already converted the operator's DISPLAY entry
+        // to RAW; storage and GM always hold raw.
         setConfig({ ...config, [field.name]: rawVal });
         if (field.source) {
             try { await write(field.source, rawVal); }
@@ -642,81 +538,31 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
     const renderConfigField = (field: TestFieldDef) => {
         if (field.name === 'sample_id') return null;
         const valid = isFieldValid(field);
+        // A field an AMS asset_ref claims gets its picker from the registry
+        // instead of from the field declaration; everything else is rendered
+        // from the schema by <TestFieldRow>, exactly as the Cycle tab does.
         const assetType = assetTypeForField(field);
-        // A schema-declared `options` list turns the field into a
-        // dropdown (skipped when an asset_ref already claims the field
-        // — that picker is sourced from AMS, not the static list).
-        const dropdownOptions = !assetType && Array.isArray(field.options) && field.options.length > 0
-            ? normalizeOptions(field.options)
-            : null;
-        const isNum = !assetType && !dropdownOptions
-            && field.type !== 'string' && field.type !== 'bool';
         return (
-            <React.Fragment key={field.name}>
-                <span className="ac-form-label">{labelOf(field)}</span>
-                {assetType ? (
+            <TestFieldRow
+                key={field.name}
+                field={field}
+                value={config[field.name]}
+                valid={valid}
+                onChange={(raw) => handleFieldChange(field, raw)}
+                onInfo={(f) => setInfoDialog({
+                    open: true,
+                    title: labelOf(f),
+                    body: <p style={{ margin: 0, whiteSpace: 'pre-wrap' }}>{f.description}</p>,
+                })}
+                control={assetType ? (
                     <AssetIdPicker
                         assetType={assetType}
                         value={config[field.name] != null ? String(config[field.name]) : ''}
                         onChange={(val) => handleFieldChange(field, val)}
                         invalid={!valid}
                     />
-                ) : dropdownOptions ? (
-                    <Dropdown
-                        value={config[field.name] ?? null}
-                        options={dropdownOptions}
-                        onChange={(e) => handleFieldChange(field, e.value)}
-                        placeholder={`Select ${field.label ?? field.name}…`}
-                        className={`ac-dropdown-clearable${!valid ? ' p-invalid' : ''}`}
-                        showClear={!field.required}
-                    />
-                ) : isNum ? (
-                    <ValueInput
-                        label={undefined}
-                        // 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}
-                        // min/max are authored in display units, matching the
-                        // value rendered above — ValueInput rejects out-of-range
-                        // entries on accept.
-                        min={field.min}
-                        max={field.max}
-                        onValueChanged={(val) => handleFieldChange(field, val)}
-                        className={!valid ? 'p-invalid' : ''}
-                    />
-                ) : (
-                    <TextInput
-                        label={undefined}
-                        value={config[field.name] != null ? String(config[field.name]) : ''}
-                        onValueChanged={(val) => handleFieldChange(field, val)}
-                        className={!valid ? 'p-invalid' : ''}
-                    />
-                )}
-                {hasDescription(field) ? (
-                    <Button
-                        icon="pi pi-info-circle"
-                        text
-                        rounded
-                        aria-label={`About ${labelOf(field)}`}
-                        onClick={() => setInfoDialog({
-                            open: true,
-                            title: labelOf(field),
-                            body: <p style={{ margin: 0, whiteSpace: 'pre-wrap' }}>{field.description}</p>,
-                        })}
-                        // Replaces a hover Tooltip — touch-friendly. The
-                        // description is shown in the shared info dialog.
-                    />
-                ) : (
-                    <span aria-hidden="true" />
-                )}
-                <span style={{ color: valid ? 'var(--green-500)' : 'var(--red-500)', display: 'flex', alignItems: 'center' }}>
-                    <i className={valid ? 'pi pi-check' : 'pi pi-times'} />
-                </span>
-            </React.Fragment>
+                ) : undefined}
+            />
         );
     };
 
@@ -772,14 +618,8 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
         if (schema) {
             for (const field of schema.config_fields) {
                 if (field.name === 'sample_id') continue;
-                const v = config[field.name];
-                const empty = v === undefined || v === '' || v === null;
-                if (field.required && empty) {
-                    issues.push(`Required field "${labelOf(field)}" is empty.`);
-                    continue;
-                }
-                const re = rangeIssue(field, v);
-                if (re) issues.push(`"${labelOf(field)}" ${re}.`);
+                const issue = fieldIssue(field, config[field.name]);
+                if (issue) issues.push(`"${labelOf(field)}" ${issue}.`);
             }
         }
         return issues;

package/src/components/tis/TestSetupView.tsx

@@ -6,7 +6,7 @@
  * the same tabbed layout and scroll behaviour without copy-pasting a
  * per-project `TestInformationView`.
  *
- * Two tabs, both self-driving from <TisProvider> (no prop threading):
+ * Up to three tabs, all self-driving from <TisProvider> (no prop threading):
  *
  *   Project tab  — <ProjectSelector> stays pinned at the top; the
  *                  <ResultHistoryTable> (Test History) scrolls beneath
@@ -14,6 +14,16 @@
  *   Test tab     — <TestSetupForm>. Its "Test Setup" header (Sample ID,
  *                  Test Method, Configuration) stays pinned; the "Test
  *                  Configuration" field list scrolls when it overflows.
+ *   Cycle tab    — <CycleConfigForm>, the per-row annotation recorded onto
+ *                  each cycle. Present only when the selected method
+ *                  declares `cycle_config_fields`, and badged when a
+ *                  required entry is missing. Auto-selected when a run
+ *                  goes active: Test setup is a pre-run concern, the
+ *                  annotation is a during-run one.
+ *
+ * The Cycle tab is deliberately not the only place this state is visible —
+ * an operator about to press Start is looking at the footer, not at a tab.
+ * Put <CycleStatusStrip> beside the Start button for that.
  *
  * The whole view fills its parent's height and confines overflow to the
  * inner scroll regions, so the tab strip and the section headers stay
@@ -22,11 +32,13 @@
  * `min-height: 0`, or a fixed-height panel) to get that behaviour.
  */
 
-import React from 'react';
+import React, { useEffect, useRef, useState } from 'react';
 import { TabView, TabPanel } from 'primereact/tabview';
 import { ProjectSelector } from './ProjectSelector';
 import { ResultHistoryTable } from './ResultHistoryTable';
 import { TestSetupForm } from './TestSetupForm';
+import { CycleConfigForm } from './CycleConfigForm';
+import { useTis } from './TisProvider';
 
 export interface TestSetupViewProps {
     /** Extra class names applied to the root element. */
@@ -40,9 +52,25 @@ export const TestSetupView: React.FC<TestSetupViewProps> = ({ className, style }
         ? `ac-test-setup-view ${className}`
         : 'ac-test-setup-view';
 
+    const tis = useTis();
+    const hasCycleConfig = tis.cycleConfigFields.length > 0;
+    const cycleIncomplete = hasCycleConfig && !tis.cycleConfig.ready;
+
+    // Which tab is showing. Controlled so the view can move the operator to
+    // the Cycle tab when a run goes active — the annotation is what they
+    // need next, and Test setup is already done by then.
+    const [activeIndex, setActiveIndex] = useState(0);
+    const prevActive = useRef(false);
+    useEffect(() => {
+        if (tis.state.active && !prevActive.current && hasCycleConfig) {
+            setActiveIndex(2);
+        }
+        prevActive.current = tis.state.active;
+    }, [tis.state.active, hasCycleConfig]);
+
     return (
         <div className={rootClass} style={style}>
-            <TabView>
+            <TabView activeIndex={activeIndex} onTabChange={(e) => setActiveIndex(e.index)}>
                 {/* Project tab: pick or create a project, then browse its
                     history. ResultHistoryTable is project-scoped (across
                     methods) by default, so this is the natural place to
@@ -66,6 +94,35 @@ export const TestSetupView: React.FC<TestSetupViewProps> = ({ className, style }
                 <TabPanel header="Test">
                     <TestSetupForm />
                 </TabPanel>
+
+                {/* Cycle tab: per-row operator annotation. Rendered only
+                    when the method declares any — a method that records
+                    nothing by hand shouldn't grow an empty tab. The header
+                    carries a warning marker when a required entry is
+                    missing, so the state is legible from the tab strip
+                    without opening it. */}
+                {hasCycleConfig && (
+                    <TabPanel
+                        header={
+                            <span style={{ display: 'inline-flex', alignItems: 'center', gap: '0.4rem' }}>
+                                Cycle
+                                {cycleIncomplete && (
+                                    <i
+                                        className="pi pi-exclamation-circle"
+                                        style={{ color: 'var(--red-500)' }}
+                                        aria-label="Cycle Configuration incomplete"
+                                    />
+                                )}
+                            </span>
+                        }
+                    >
+                        <div className="ac-test-setup-view__tab">
+                            <div className="ac-test-setup-view__scroll">
+                                <CycleConfigForm />
+                            </div>
+                        </div>
+                    </TabPanel>
+                )}
             </TabView>
         </div>
     );