@adcops/autocore-react 3.3.105 → 3.3.109

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

@@ -7,7 +7,7 @@ import { Dropdown } from 'primereact/dropdown';
 import { Checkbox } from 'primereact/checkbox';
 import { InputNumber } from 'primereact/inputnumber';
 import { FormRow } from '../../forms/FormRow';
-import type { TestField } from '../types';
+import type { TestField, AggFn, AggFrom, AggregateSpec } from '../types';
 
 const FIELD_TYPES: { label: string; value: string }[] = [
     { label: 'string', value: 'string' },
@@ -20,6 +20,21 @@ const FIELD_TYPES: { label: string; value: string }[] = [
     { label: 'bool', value: 'bool' },
 ];
 
+// '' = no aggregation (the field is supplied by the analysis script).
+const AGG_FNS: { label: string; value: '' | AggFn }[] = [
+    { label: '— none (analysis-fed) —', value: '' },
+    { label: 'avg', value: 'avg' },
+    { label: 'min', value: 'min' },
+    { label: 'max', value: 'max' },
+    { label: 'stddev', value: 'stddev' },
+    { label: 'count (# included tests)', value: 'count' },
+];
+
+const AGG_FROMS: { label: string; value: AggFrom }[] = [
+    { label: 'cycle field (every cycle, every test)', value: 'cycle_fields' },
+    { label: 'result (one value per test)', value: 'results' },
+];
+
 export interface TestFieldDialogProps {
     visible: boolean;
     initial: TestField | null;
@@ -27,23 +42,49 @@ export interface TestFieldDialogProps {
     onSave: (field: TestField) => void;
     /** Names already in use within the same array — for uniqueness validation. */
     siblingNames: string[];
+    /** True when this field belongs to `results_fields` — only then is the
+     *  cross-test Aggregate section shown. */
+    isResultsField?: boolean;
+    /** Candidate target field names for an aggregate's `of`, by source. */
+    cycleFieldNames?: string[];
+    resultsFieldNames?: string[];
 }
 
 const blank: TestField = { name: '', type: 'f32' };
 
 export const TestFieldDialog: React.FC<TestFieldDialogProps> = ({
     visible, initial, onCancel, onSave, siblingNames,
+    isResultsField = false, cycleFieldNames = [], resultsFieldNames = [],
 }) => {
     const [draft, setDraft] = useState<TestField>(blank);
+    // `default` is edited as free text so a numeric literal, a string, or an
+    // `${fqdn}` token can all be entered in one field; it's coerced on save.
+    const [defaultText, setDefaultText] = useState<string>('');
     const [error, setError] = useState<string | null>(null);
 
     useEffect(() => {
         if (visible) {
             setDraft(initial ? { ...initial } : { ...blank });
+            setDefaultText(initial?.default == null ? '' : String(initial.default));
             setError(null);
         }
     }, [visible, initial]);
 
+    // Turn the free-text Default into its stored form: an `${fqdn}` token and
+    // other non-numerics stay strings; numeric/bool literals are stored typed.
+    const coerceDefault = (s: string): unknown => {
+        const t = s.trim();
+        if (t === '') return undefined;
+        if (t.startsWith('${')) return t;
+        if (t === 'true') return true;
+        if (t === 'false') return false;
+        if (/^-?\d*\.?\d+$/.test(t)) {
+            const n = Number(t);
+            if (Number.isFinite(n)) return n;
+        }
+        return t;
+    };
+
     const validate = (f: TestField): string | null => {
         if (!f.name.trim()) return 'Field name is required.';
         if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(f.name)) {
@@ -51,13 +92,40 @@ export const TestFieldDialog: React.FC<TestFieldDialogProps> = ({
         }
         const dupOfOther = siblingNames.some(n => n === f.name && n !== initial?.name);
         if (dupOfOther) return `A field named "${f.name}" already exists in this array.`;
+        if (typeof f.min === 'number' && typeof f.max === 'number' && f.min > f.max) {
+            return `Min (${f.min}) cannot be greater than Max (${f.max}).`;
+        }
+        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).`;
+        }
         return null;
     };
 
+    // Build the aggregate spec from the chosen function. '' clears it; count
+    // drops of/from (it reduces over the set of included tests, not a field).
+    const setAggFn = (fn: '' | AggFn) => {
+        if (fn === '') { setDraft({ ...draft, aggregate: undefined }); return; }
+        if (fn === 'count') { setDraft({ ...draft, aggregate: { fn: 'count' } }); return; }
+        const next: AggregateSpec = { fn, of: draft.aggregate?.of, from: draft.aggregate?.from ?? 'cycle_fields' };
+        setDraft({ ...draft, aggregate: next });
+    };
+
+    const agg = draft.aggregate;
+    const aggFrom: AggFrom = agg?.from ?? 'cycle_fields';
+    // `of` candidates depend on the source; exclude this field's own name so
+    // a result can't aggregate itself.
+    const aggTargets = (aggFrom === 'results' ? resultsFieldNames : cycleFieldNames)
+        .filter(n => n && n !== draft.name)
+        .map(n => ({ label: n, value: n }));
+
     const handleSave = () => {
-        const err = validate(draft);
+        const candidate: TestField = { ...draft };
+        const dv = coerceDefault(defaultText);
+        if (dv === undefined) delete (candidate as { default?: unknown }).default;
+        else candidate.default = dv;
+        const err = validate(candidate);
         if (err) { setError(err); return; }
-        onSave(draft);
+        onSave(candidate);
     };
 
     return (
@@ -118,6 +186,74 @@ 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>
+            <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>
+            <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.">
+                <InputText
+                    value={defaultText}
+                    onChange={(e) => setDefaultText(e.target.value)}
+                    placeholder="e.g. 5  or  ${gm.safe_speed}"
+                />
+            </FormRow>
+            {isResultsField && (
+                <>
+                    <div style={{ borderTop: '1px solid #e5e7eb', margin: '0.75rem 0 0.25rem' }} />
+                    <FormRow
+                        label="Aggregate"
+                        hint="Cross-test rollup. When set, this result is derived server-side over the non-excluded tests sharing the same sample_id — the analysis script does not supply it."
+                    >
+                        <Dropdown
+                            value={agg?.fn ?? ''}
+                            options={AGG_FNS}
+                            onChange={(e) => setAggFn(e.value)}
+                        />
+                    </FormRow>
+                    {agg && agg.fn !== 'count' && (
+                        <>
+                            <FormRow label="Aggregate from" hint="Which per-test source the target field is read from.">
+                                <Dropdown
+                                    value={aggFrom}
+                                    options={AGG_FROMS}
+                                    onChange={(e) =>
+                                        setDraft({ ...draft, aggregate: { ...agg, from: e.value } })
+                                    }
+                                />
+                            </FormRow>
+                            <FormRow label="Aggregate of" required hint="The field to reduce across tests.">
+                                <Dropdown
+                                    value={agg.of ?? null}
+                                    options={aggTargets}
+                                    onChange={(e) =>
+                                        setDraft({ ...draft, aggregate: { ...agg, of: e.value || undefined } })
+                                    }
+                                    editable
+                                    placeholder={aggTargets.length ? 'Select a field' : `No ${aggFrom} defined yet`}
+                                />
+                            </FormRow>
+                        </>
+                    )}
+                </>
+            )}
             <FormRow label="Description" hint="Hover tooltip in the form.">
                 <InputTextarea
                     rows={2}

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

@@ -22,6 +22,28 @@ export interface TestField {
     description?: string;
     default?: unknown;
     scale?: number;
+    /** 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;
+    /** 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. */
+    aggregate?: AggregateSpec;
+}
+
+export type AggFn = 'avg' | 'min' | 'max' | 'stddev' | 'count';
+export type AggFrom = 'cycle_fields' | 'results';
+
+export interface AggregateSpec {
+    /** Reduction applied across the gathered values. */
+    fn: AggFn;
+    /** Field to aggregate — a cycle_field or results_field name (per `from`).
+     *  Ignored for `fn: "count"` (which counts included tests). */
+    of?: string;
+    /** Which per-test source `of` is read from. Defaults to "cycle_fields". */
+    from?: AggFrom;
 }
 
 export interface ChartAxis {

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

@@ -33,8 +33,46 @@ export function validateMethod(methodId: string, m: TestMethod): ValidationError
             } else {
                 seen.add(f.name);
             }
+            if (typeof f.min === 'number' && typeof f.max === 'number' && f.min > f.max) {
+                errs.push({ path: `${key}.${i}.min`, message: `${methodId}.${key}.${f.name}: min (${f.min}) is greater than max (${f.max})` });
+            }
+        });
+    }
+
+    // Aggregate specs: only on results_fields; target must exist in the
+    // chosen source array and be numeric. `count` needs no target. Mirrors
+    // tis_servelet::validate_method.
+    const NUMERIC_TYPES = new Set(['i32', 'i64', 'u32', 'u64', 'f32', 'f64']);
+    const cycleTypes = new Map<string, string>(
+        ((m.cycle_fields as TestField[] | undefined) ?? []).map((f) => [f.name, String(f.type)])
+    );
+    const resultTypes = new Map<string, string>(
+        ((m.results_fields as TestField[] | undefined) ?? []).map((f) => [f.name, String(f.type)])
+    );
+    for (const key of ['project_fields', 'config_fields', 'cycle_fields'] as const) {
+        ((m[key] as TestField[] | undefined) ?? []).forEach((f, i) => {
+            if (f.aggregate) {
+                errs.push({ path: `${key}.${i}.aggregate`, message: `${methodId}.${key}.${f.name}: aggregate is only valid on results_fields` });
+            }
         });
     }
+    ((m.results_fields as TestField[] | undefined) ?? []).forEach((f, i) => {
+        const a = f.aggregate;
+        if (!a || a.fn === 'count') return;
+        const of = a.of?.trim();
+        if (!of) {
+            errs.push({ path: `results_fields.${i}.aggregate`, message: `${methodId}.results_fields.${f.name}: aggregate "${a.fn}" requires a target field (of)` });
+            return;
+        }
+        const lookup = (a.from ?? 'cycle_fields') === 'results' ? resultTypes : cycleTypes;
+        const srcLabel = (a.from ?? 'cycle_fields') === 'results' ? 'results_fields' : 'cycle_fields';
+        const ty = lookup.get(of);
+        if (ty === undefined) {
+            errs.push({ path: `results_fields.${i}.aggregate`, message: `${methodId}.results_fields.${f.name}: aggregate "of" references "${of}" which is not a ${srcLabel} of this method` });
+        } else if (!NUMERIC_TYPES.has(ty)) {
+            errs.push({ path: `results_fields.${i}.aggregate`, message: `${methodId}.results_fields.${f.name}: aggregate target "${of}" has non-numeric type "${ty}"` });
+        }
+    });
 
     // Build sets for axis-reference resolution.
     const knownFields = new Set<string>();