@adcops/autocore-react 3.5.3 → 3.5.7

package/src/components/tis-editor/editor/TestFieldDialog.tsx

@@ -1,4 +1,4 @@
-import { useEffect, useState } from 'react';
+import { useContext, useEffect, useMemo, useState } from 'react';
 import { Dialog } from 'primereact/dialog';
 import { Button } from 'primereact/button';
 import { InputText } from 'primereact/inputtext';
@@ -8,6 +8,11 @@ import { Checkbox } from 'primereact/checkbox';
 import { InputNumber } from 'primereact/inputnumber';
 import { FormRow } from '../../forms/FormRow';
 import type { TestField, AggFn, AggFrom, AggScope, AggregateSpec } from '../types';
+// One home for bound parsing/formatting — shared with the operator-facing
+// form so the editor and the runtime can never disagree on what a bound is.
+import { boundText, parseBound, boundInvalid } from '../../tis/TestFieldRow';
+import { AutoCoreTagContext } from '../../../core/AutoCoreTagContext';
+
 
 const FIELD_TYPES: { label: string; value: string }[] = [
     { label: 'string', value: 'string' },
@@ -83,6 +88,17 @@ export const TestFieldDialog: React.FC<TestFieldDialogProps> = ({
     const [defaultText, setDefaultText] = useState<string>('');
     const [error, setError] = useState<string | null>(null);
 
+    // The quantity names this machine actually declares, from the resolved
+    // units table. Offered as a dropdown so an author picks a row that exists
+    // instead of typing one that silently never resolves — but `editable`, so a
+    // method can still be authored against a quantity the bench machine has yet
+    // to declare.
+    const { scales } = useContext(AutoCoreTagContext);
+    const quantityOptions = useMemo(
+        () => Object.keys(scales ?? {}).sort().map(q => ({ label: q, value: q })),
+        [scales],
+    );
+
     useEffect(() => {
         if (visible) {
             setDraft(initial ? { ...initial } : { ...blank });
@@ -116,6 +132,13 @@ export const TestFieldDialog: React.FC<TestFieldDialogProps> = ({
         if (typeof f.min === 'number' && typeof f.max === 'number' && f.min > f.max) {
             return `Min (${f.min}) cannot be greater than Max (${f.max}).`;
         }
+        // A bound that is neither a number nor a well-formed token resolves to
+        // NO bound at run time — silently unlimited. Refuse the save instead.
+        for (const which of ['min', 'max'] as const) {
+            if (boundInvalid(f[which])) {
+                return `${which === 'min' ? 'Min' : 'Max'} must be a number or an FQDN token like \${gm.some_var} — "${f[which]}" is neither.`;
+            }
+        }
         if (f.aggregate && f.aggregate.fn !== 'count' && !f.aggregate.of?.trim()) {
             return `Aggregate "${f.aggregate.fn}" needs a target field (the field to ${f.aggregate.fn} across tests).`;
         }
@@ -189,7 +212,23 @@ export const TestFieldDialog: React.FC<TestFieldDialogProps> = ({
                     editable
                 />
             </FormRow>
-            <FormRow label="Units" hint="Display label, appended to form labels (e.g. m/s).">
+            <FormRow
+                label="Quantity"
+                hint="Ties this field to a row of the machine's units.json, so it follows the operator's Metric/Imperial choice and takes its unit label from the active system. Set this in preference to Units/Scale, which are fixed."
+            >
+                <Dropdown
+                    value={draft.quantity ?? ''}
+                    options={quantityOptions}
+                    onChange={(e) => setDraft({ ...draft, quantity: e.value || undefined })}
+                    placeholder="— none (fixed Units/Scale below) —"
+                    showClear
+                    editable
+                />
+            </FormRow>
+            <FormRow
+                label="Units"
+                hint="Fixed display label appended to form labels (e.g. m/s). Ignored when Quantity is set — the active unit system supplies the label."
+            >
                 <InputText
                     value={draft.units ?? ''}
                     onChange={(e) => setDraft({ ...draft, units: e.target.value || undefined })}
@@ -241,26 +280,26 @@ export const TestFieldDialog: React.FC<TestFieldDialogProps> = ({
                     maxFractionDigits={9}
                 />
             </FormRow>
-            <FormRow label="Min" hint="Optional lower bound the operator can enter (display units). Blank = no minimum.">
-                <InputNumber
-                    value={draft.min ?? null}
-                    onValueChange={(e) =>
-                        setDraft({ ...draft, min: typeof e.value === 'number' ? e.value : undefined })
-                    }
-                    mode="decimal"
-                    minFractionDigits={0}
-                    maxFractionDigits={9}
+            <FormRow
+                label="Min"
+                hint="Optional lower bound the operator can enter (display units). Blank = no minimum. Or bind it to the machine with an FQDN token like ${gm.press_force_min_n} — for a bound that moves, e.g. a load-cell force ceiling."
+            >
+                <InputText
+                    value={boundText(draft.min)}
+                    onChange={(e) => setDraft({ ...draft, min: parseBound(e.target.value) })}
+                    className={boundInvalid(draft.min) ? 'p-invalid' : ''}
+                    placeholder="number or ${gm.…}"
                 />
             </FormRow>
-            <FormRow label="Max" hint="Optional upper bound the operator can enter (display units). Blank = no maximum.">
-                <InputNumber
-                    value={draft.max ?? null}
-                    onValueChange={(e) =>
-                        setDraft({ ...draft, max: typeof e.value === 'number' ? e.value : undefined })
-                    }
-                    mode="decimal"
-                    minFractionDigits={0}
-                    maxFractionDigits={9}
+            <FormRow
+                label="Max"
+                hint="Optional upper bound the operator can enter (display units). Blank = no maximum. Or bind it to the machine with an FQDN token like ${gm.press_force_max_n}."
+            >
+                <InputText
+                    value={boundText(draft.max)}
+                    onChange={(e) => setDraft({ ...draft, max: parseBound(e.target.value) })}
+                    className={boundInvalid(draft.max) ? 'p-invalid' : ''}
+                    placeholder="number or ${gm.…}"
                 />
             </FormRow>
             <FormRow label="Default" hint="Applied every time the method loads (operator can override). A literal (display units) like 5, or an FQDN token like ${gm.safe_speed} that snapshots that value on load.">

package/src/components/tis-editor/types.ts

@@ -15,6 +15,11 @@ export type FieldType =
 export interface TestField {
     name: string;
     type: FieldType | string;
+    /** Scale-group name from the machine's `units.json` ("force", "position",
+     *  …). What makes this field follow the operator's Metric/Imperial choice;
+     *  supersedes `units` / `scale`. Declared here so the editor round-trips it
+     *  — see `TestFieldDialog`'s Quantity row. */
+    quantity?: string;
     units?: string;
     required?: boolean;
     source?: string;
@@ -25,8 +30,12 @@ export interface TestField {
     /** Optional inclusive bounds for the operator's numeric value, authored
      *  in display units (same convention as `default`/`scale`). The form's
      *  numeric input rejects values outside `[min, max]`. */
-    min?: number;
-    max?: number;
+    /** Inclusive bounds. A number is in display units; a string is an FQDN
+     *  token `"${gm.<var>}"` resolved live from the machine — see
+     *  `TestFieldRow.resolveBound`. The editor must preserve a token it does
+     *  not understand rather than coercing it to a number. */
+    min?: number | string;
+    max?: number | string;
     /** results_fields only: a cross-test rollup derived server-side over the
      *  non-excluded runs sharing this test's sample_id. When set, the field
      *  is NOT supplied by the analysis script — the server computes it. */