@adcops/autocore-react 3.3.89 → 3.3.91

package/src/components/tis/TisProvider.tsx

@@ -181,6 +181,33 @@ export interface TisContextValue {
      *  method selection or after a run completes. */
     clearStagedConfig: () => void;
 
+    /** methodId whose schema defaults have already been seeded into
+     *  `stagedConfig` (and written to GM for source-bound fields) for
+     *  the current session. `<TestSetupForm>` gates its one-shot
+     *  "apply defaults" effect on this value so it only fires on an
+     *  actual method change — not on form remount when the operator
+     *  switches tabs. Empty string means "no method seeded yet."
+     *  Reset to `''` by `clearStagedConfig()` so the next staged test
+     *  re-seeds correctly. */
+    defaultsAppliedForMethod: string;
+    /** Mark the given methodId as having been seeded. The form calls
+     *  this immediately after writing the defaults, so subsequent
+     *  remounts skip re-application. */
+    markDefaultsAppliedForMethod: (methodId: string) => void;
+
+    /** `name` of the method configuration the operator currently has
+     *  selected (see `TestMethod.configurations`). Empty string when the
+     *  active method declares no configurations, or none is chosen yet.
+     *  Held on the provider — like `stagedConfig` — so the selection
+     *  survives `<TestSetupForm>` remounting on a tab switch. HMI-only:
+     *  it scopes which override set is shown; the override *values* it
+     *  applies are what actually get recorded. */
+    configurationName: string;
+    /** Set the selected configuration name. The form calls this when the
+     *  seeding effect auto-applies the first configuration and when the
+     *  operator accepts a different one in the picker dialog. */
+    setConfigurationName: (name: string) => void;
+
     /** Fetch the run list for a (project, method?) pair. Method may be
      *  omitted to aggregate runs across every method in the project —
      *  the History tab uses this. */
@@ -224,6 +251,10 @@ const TisContext = createContext<TisContextValue>({
     stagedConfig: {},
     setStagedConfig: () => {},
     clearStagedConfig: () => {},
+    defaultsAppliedForMethod: '',
+    markDefaultsAppliedForMethod: () => {},
+    configurationName: '',
+    setConfigurationName: () => {},
     fetchRuns: async () => [],
     fetchRun: async () => null,
     runCache: {},
@@ -646,8 +677,26 @@ export const TisProvider: React.FC<TisProviderProps> = ({ children, defaultMetho
     const setStagedConfig = useCallback((patch: Record<string, any>) => {
         setStagedConfigState(prev => ({ ...prev, ...patch }));
     }, []);
+    // Tracks which methodId's schema defaults have been seeded into
+    // stagedConfig + GM during this session. Owned by the provider (not
+    // by <TestSetupForm>) so the marker survives the form unmounting
+    // when the operator switches tabs — otherwise the form's seed
+    // effect re-fires on every remount and clobbers operator edits.
+    const [defaultsAppliedForMethod, setDefaultsAppliedForMethod] = useState<string>('');
+    const markDefaultsAppliedForMethod = useCallback((methodId: string) => {
+        setDefaultsAppliedForMethod(methodId);
+    }, []);
+    // Selected method configuration (TestMethod.configurations). Lives
+    // alongside stagedConfig so it survives a form remount; reset on a
+    // fresh stage so the next test re-applies the method's first config.
+    const [configurationName, setConfigurationName] = useState<string>('');
     const clearStagedConfig = useCallback(() => {
         setStagedConfigState({});
+        // Re-seed defaults on the next stage. Without this, the form
+        // would render empty after start_test (config cleared) because
+        // the seed gate would still consider the method "applied."
+        setDefaultsAppliedForMethod('');
+        setConfigurationName('');
     }, []);
 
     const value: TisContextValue = useMemo(() => ({
@@ -656,6 +705,8 @@ export const TisProvider: React.FC<TisProviderProps> = ({ children, defaultMetho
         existingProjects, projectKnown, refreshProjects, markProjectJustCreated,
         projectFields, projectFieldsLoaded, loadProjectFields, setProjectFields,
         stagedConfig, setStagedConfig, clearStagedConfig,
+        defaultsAppliedForMethod, markDefaultsAppliedForMethod,
+        configurationName, setConfigurationName,
         fetchRuns, fetchRun, runCache,
     }), [
         schemas, projectAssetRefs, defaultMethodId, schemasLoaded,
@@ -663,6 +714,8 @@ export const TisProvider: React.FC<TisProviderProps> = ({ children, defaultMetho
         existingProjects, projectKnown, refreshProjects, markProjectJustCreated,
         projectFields, projectFieldsLoaded, loadProjectFields, setProjectFields,
         stagedConfig, setStagedConfig, clearStagedConfig,
+        defaultsAppliedForMethod, markDefaultsAppliedForMethod,
+        configurationName, setConfigurationName,
         fetchRuns, fetchRun, runCache,
     ]);
 

package/src/components/tis/useRawCycleData.ts

@@ -73,6 +73,10 @@ export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataRe
     const [envelope, setEnvelope]           = useState<any | null>(null);
     const [loading, setLoading]             = useState(false);
     const [error, setError]                 = useState<string | null>(null);
+    // Bumped to force a re-fetch of the *current* cycle's envelope when its
+    // on-disk content changes without the cycle selection changing — today
+    // that's a `chart_regions_set` patch landing for the viewed cycle.
+    const [refreshNonce, setRefreshNonce]   = useState(0);
 
     // Track whether the user has explicitly pinned a cycle. When false,
     // the live-follow path is free to advance the picker to the newest
@@ -174,8 +178,23 @@ export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataRe
                 setSelectedCycle(newLatest);
             }
         };
-        const id = subscribe('tis.raw_data_added', onRawAdded);
-        return () => { unsubscribe(id); };
+        // Region bands patched onto a cycle that already has a trace file.
+        // The cycle list/selection don't change, so re-listing isn't enough —
+        // force a re-fetch of the envelope iff the patched cycle is the one
+        // on screen, which is all that needs the new `regions`.
+        const onRegionsSet = (payload: any) => {
+            if (payload?.project_id !== projectId) return;
+            if (payload?.method_id  !== methodId)  return;
+            if (payload?.run_id     !== runId)     return;
+            if (payload?.name       !== blobName)  return;
+            if (payload?.cycle_index === selectedRef.current) {
+                setRefreshNonce(n => n + 1);
+            }
+        };
+
+        const id  = subscribe('tis.raw_data_added',      onRawAdded);
+        const id2 = subscribe('tis.chart_regions_set', onRegionsSet);
+        return () => { unsubscribe(id); unsubscribe(id2); };
     }, [enabled, projectId, methodId, runId, blobName, listCycles, subscribe, unsubscribe]);
 
     // Lazy blob fetch — runs whenever identifiers / selectedCycle change.
@@ -221,7 +240,7 @@ export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataRe
             }
         })();
         return () => { cancelled = true; };
-    }, [enabled, projectId, methodId, runId, blobName, selectedCycle, invoke]);
+    }, [enabled, projectId, methodId, runId, blobName, selectedCycle, invoke, refreshNonce]);
 
     // Public setter wraps setSelectedCycle and flips userPinnedRef so
     // an operator's manual pick freezes the picker for the rest of the

package/src/components/tis-editor/TisConfigEditor.css

@@ -119,3 +119,23 @@
     gap: 0.25rem;
     margin-bottom: 0.25rem;
 }
+
+/* Portrait displays (e.g. wall-mounted HMIs rotated to portrait) don't
+   have the horizontal room for a fixed 320px selection pane beside the
+   content pane — the content pane gets squeezed and cut off. Stack the
+   two panes instead: the method-selection list becomes a capped,
+   scrollable band on top, and the editor takes the remaining height. */
+@media (orientation: portrait) {
+    .tis-editor__body {
+        flex-direction: column;
+    }
+
+    .tis-editor__sidebar {
+        /* Cap the list at ~35% of the body height (it scrolls internally
+           via the DataTable's scrollHeight="flex"); the editor below gets
+           the rest. Drop the fixed 320px width — full width when stacked. */
+        flex: 0 1 35%;
+        border-right: none;
+        border-bottom: 1px solid var(--surface-d, #e2e8f0);
+    }
+}

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

@@ -0,0 +1,242 @@
+/**
+ * ConfigurationsEditor — manages a method's named `configurations`
+ * (e.g. translational_traction's "Plaque" vs "Shoe"). Each configuration
+ * carries a sparse set of config_field overrides; only the fields whose
+ * value is specific to that configuration need to be listed.
+ *
+ * Mirrors <AssetRefsEditor>: a DataTable of the declared configurations
+ * plus an add/edit Dialog. The override sub-editor is a small key/value
+ * table whose key is a dropdown of the method's own config_fields, so the
+ * author can only target fields that actually exist, and values are
+ * coerced to the field's declared type on save.
+ */
+
+import { useMemo, useState } from 'react';
+import { Dialog } from 'primereact/dialog';
+import { Button } from 'primereact/button';
+import { InputText } from 'primereact/inputtext';
+import { InputTextarea } from 'primereact/inputtextarea';
+import { Dropdown } from 'primereact/dropdown';
+import { DataTable } from 'primereact/datatable';
+import { Column } from 'primereact/column';
+import { FormSection } from '../../forms/FormSection';
+import { FormRow } from '../../forms/FormRow';
+import type { TestConfiguration, TestField, TestMethod } from '../types';
+
+export interface ConfigurationsEditorProps {
+    method: TestMethod;
+    onChange: (next: TestMethod) => void;
+}
+
+const NUMERIC_TYPES = new Set(['i32', 'i64', 'u32', 'u64', 'f32', 'f64']);
+
+/** Coerce a raw text entry to the declared field type. Non-numeric text
+ *  for a numeric field is left as the string so validation can flag it. */
+const coerceValue = (field: TestField | undefined, raw: string): unknown => {
+    const t = field?.type ?? 'string';
+    if (t === 'bool') return raw === 'true' || raw === '1';
+    if (NUMERIC_TYPES.has(t)) {
+        const n = Number(raw);
+        return raw.trim() !== '' && Number.isFinite(n) ? n : raw;
+    }
+    return raw;
+};
+
+interface OverrideRow { field: string; value: string }
+
+const blank = (): TestConfiguration => ({ name: '', defaults: {} });
+
+const toRows = (defaults: Record<string, unknown> | undefined): OverrideRow[] =>
+    Object.entries(defaults ?? {}).map(([field, value]) => ({ field, value: String(value) }));
+
+export const ConfigurationsEditor: React.FC<ConfigurationsEditorProps> = ({ method, onChange }) => {
+    const configs: TestConfiguration[] = (method.configurations as TestConfiguration[]) ?? [];
+    const configFields: TestField[] = (method.config_fields as TestField[]) ?? [];
+
+    const [dialogOpen, setDialogOpen] = useState(false);
+    const [editingIdx, setEditingIdx] = useState<number | null>(null);
+    const [draft, setDraft] = useState<TestConfiguration>(blank());
+    const [rows, setRows] = useState<OverrideRow[]>([]);
+    const [error, setError] = useState<string | null>(null);
+
+    // Fields the author can override (skip the implicit sample_id).
+    const fieldOptions = useMemo(
+        () => configFields
+            .filter(f => f.name && f.name !== 'sample_id')
+            .map(f => ({ label: f.units ? `${f.name} [${f.units}]` : f.name, value: f.name })),
+        [configFields],
+    );
+    const fieldByName = useMemo(() => {
+        const m = new Map<string, TestField>();
+        configFields.forEach(f => m.set(f.name, f));
+        return m;
+    }, [configFields]);
+
+    const openNew = () => {
+        setEditingIdx(null);
+        setDraft(blank());
+        setRows([]);
+        setError(null);
+        setDialogOpen(true);
+    };
+    const openEdit = (i: number) => {
+        setEditingIdx(i);
+        setDraft({ ...configs[i] });
+        setRows(toRows(configs[i].defaults));
+        setError(null);
+        setDialogOpen(true);
+    };
+
+    const validate = (c: TestConfiguration): string | null => {
+        if (!c.name.trim()) return 'Name is required.';
+        if (configs.some((o, i) => o.name === c.name && i !== editingIdx)) {
+            return `A configuration named "${c.name}" already exists.`;
+        }
+        const seen = new Set<string>();
+        for (const r of rows) {
+            if (!r.field) return 'Every override row must pick a field.';
+            if (seen.has(r.field)) return `Field "${r.field}" is overridden more than once.`;
+            seen.add(r.field);
+            if (!fieldByName.has(r.field)) return `"${r.field}" is not a config_field on this method.`;
+        }
+        return null;
+    };
+
+    const handleSave = () => {
+        const err = validate(draft);
+        if (err) { setError(err); return; }
+        const defaults: Record<string, unknown> = {};
+        for (const r of rows) {
+            defaults[r.field] = coerceValue(fieldByName.get(r.field), r.value);
+        }
+        const saved: TestConfiguration = {
+            name: draft.name.trim(),
+            ...(draft.label?.trim() ? { label: draft.label.trim() } : {}),
+            ...(draft.description?.trim() ? { description: draft.description.trim() } : {}),
+            defaults,
+        };
+        const next = [...configs];
+        if (editingIdx === null) next.push(saved);
+        else next[editingIdx] = saved;
+        onChange({ ...method, configurations: next });
+        setDialogOpen(false);
+    };
+
+    const handleRemove = (i: number) => {
+        if (!window.confirm(`Remove configuration "${configs[i].name}"?`)) return;
+        onChange({ ...method, configurations: configs.filter((_, idx) => idx !== i) });
+    };
+
+    const addRow = () => setRows([...rows, { field: '', value: '' }]);
+    const updateRow = (i: number, patch: Partial<OverrideRow>) =>
+        setRows(rows.map((r, idx) => (idx === i ? { ...r, ...patch } : r)));
+    const removeRow = (i: number) => setRows(rows.filter((_, idx) => idx !== i));
+
+    const overridesSummary = (c: TestConfiguration): string => {
+        const entries = Object.entries(c.defaults ?? {});
+        if (entries.length === 0) return '—';
+        return entries.map(([k, v]) => `${k}=${String(v)}`).join(', ');
+    };
+
+    const rowActions = (_r: TestConfiguration, opts: { rowIndex: number }) => (
+        <div style={{ display: 'flex', gap: '0.25rem' }}>
+            <Button icon="pi pi-pencil" className="p-button-text p-button-sm" onClick={() => openEdit(opts.rowIndex)} />
+            <Button icon="pi pi-trash" className="p-button-text p-button-danger p-button-sm" onClick={() => handleRemove(opts.rowIndex)} />
+        </div>
+    );
+
+    return (
+        <>
+            <FormSection
+                title="Configurations"
+                description="Named, ready-to-use override sets (e.g. Plaque vs Shoe). Selecting one in Test Setup writes its values into the matching config fields; the method's first configuration is applied automatically."
+                actions={<Button label="Add configuration" icon="pi pi-plus" size="small" onClick={openNew} />}
+            >
+                <DataTable value={configs} dataKey="name" emptyMessage="No configurations declared.">
+                    <Column field="name" header="Name" style={{ width: '10rem' }} />
+                    <Column header="Label" body={(c: TestConfiguration) => c.label ?? '—'} style={{ width: '10rem' }} />
+                    <Column header="Overrides" body={overridesSummary} />
+                    <Column header="" body={rowActions} style={{ width: '6rem' }} />
+                </DataTable>
+            </FormSection>
+
+            <Dialog
+                header={editingIdx === null ? 'New configuration' : `Edit configuration: ${configs[editingIdx ?? 0]?.name}`}
+                visible={dialogOpen}
+                onHide={() => setDialogOpen(false)}
+                style={{ width: '44rem' }}
+            >
+                {error && <div style={{ color: '#dc2626', marginBottom: '0.5rem' }}>{error}</div>}
+                <FormRow label="Name" required hint="Canonical key — unique within the method.">
+                    <InputText value={draft.name} onChange={(e) => setDraft({ ...draft, name: e.target.value })} placeholder="e.g. plaque" />
+                </FormRow>
+                <FormRow label="Label" hint="Shown in the Configuration picker. Falls back to Name.">
+                    <InputText value={draft.label ?? ''} onChange={(e) => setDraft({ ...draft, label: e.target.value || undefined })} placeholder="e.g. Plaque" />
+                </FormRow>
+                <FormRow label="Description" hint="Shown beside the dropdown in the picker dialog.">
+                    <InputTextarea rows={2} value={draft.description ?? ''} onChange={(e) => setDraft({ ...draft, description: e.target.value || undefined })} />
+                </FormRow>
+
+                <FormSection
+                    title="Field overrides"
+                    description="Only list fields whose value is specific to this configuration. Values are authored in display units, same as a field's default."
+                    actions={
+                        <Button
+                            label="Add override"
+                            icon="pi pi-plus"
+                            size="small"
+                            onClick={addRow}
+                            disabled={fieldOptions.length === 0}
+                        />
+                    }
+                >
+                    {fieldOptions.length === 0 ? (
+                        <small style={{ color: 'var(--text-secondary-color)' }}>
+                            This method has no config_fields to override yet — add some on the Fields tab first.
+                        </small>
+                    ) : rows.length === 0 ? (
+                        <small style={{ color: 'var(--text-secondary-color)' }}>No overrides — this configuration uses every field's base default.</small>
+                    ) : (
+                        <div style={{ display: 'flex', flexDirection: 'column', gap: '0.5rem' }}>
+                            {rows.map((r, i) => {
+                                const f = fieldByName.get(r.field);
+                                return (
+                                    <div key={i} style={{ display: 'flex', gap: '0.5rem', alignItems: 'center' }}>
+                                        <Dropdown
+                                            value={r.field || null}
+                                            options={fieldOptions}
+                                            onChange={(e) => updateRow(i, { field: e.value })}
+                                            placeholder="Field"
+                                            style={{ flex: '0 0 16rem' }}
+                                        />
+                                        {f?.type === 'bool' ? (
+                                            <Dropdown
+                                                value={r.value === 'true' || r.value === '1' ? 'true' : 'false'}
+                                                options={[{ label: 'true', value: 'true' }, { label: 'false', value: 'false' }]}
+                                                onChange={(e) => updateRow(i, { value: e.value })}
+                                                style={{ flex: 1 }}
+                                            />
+                                        ) : (
+                                            <InputText
+                                                value={r.value}
+                                                onChange={(e) => updateRow(i, { value: e.target.value })}
+                                                placeholder={f?.type && NUMERIC_TYPES.has(f.type) ? 'number' : 'value'}
+                                                style={{ flex: 1 }}
+                                            />
+                                        )}
+                                        <Button icon="pi pi-trash" className="p-button-text p-button-danger p-button-sm" onClick={() => removeRow(i)} />
+                                    </div>
+                                );
+                            })}
+                        </div>
+                    )}
+                </FormSection>
+
+                <div style={{ display: 'flex', justifyContent: 'flex-end', gap: '0.5rem', marginTop: '1rem' }}>
+                    <Button label="Cancel" className="p-button-text" onClick={() => setDialogOpen(false)} />
+                    <Button label="Save" onClick={handleSave} />
+                </div>
+            </Dialog>
+        </>
+    );
+};

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

@@ -13,6 +13,7 @@ import { Button } from 'primereact/button';
 import { CodeEditor } from '../../CodeEditor';
 import { IdentitySection } from './IdentitySection';
 import { FieldArrayEditor } from './FieldArrayEditor';
+import { ConfigurationsEditor } from './ConfigurationsEditor';
 import { ViewsEditor } from './ViewsEditor';
 import { RawDataEditor } from './RawDataEditor';
 import { AssetRefsEditor } from './AssetRefsEditor';
@@ -140,6 +141,9 @@ export const MethodFormEditor: React.FC<MethodFormEditorProps> = ({
                         <FieldArrayEditor arrayKey="cycle_fields"   method={draft} onChange={handleFormChange} />
                         <FieldArrayEditor arrayKey="results_fields" method={draft} onChange={handleFormChange} />
                     </TabPanel>
+                    <TabPanel header="Configurations">
+                        <ConfigurationsEditor method={draft} onChange={handleFormChange} />
+                    </TabPanel>
                     <TabPanel header="Views">
                         <ViewsEditor method={draft} onChange={handleFormChange} />
                     </TabPanel>

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

@@ -78,6 +78,19 @@ export interface AnalysisShape {
     function: string;
 }
 
+/**
+ * One named configuration for a method — a sparse set of config_field
+ * overrides (e.g. "Plaque" vs "Shoe"). `defaults` only needs to carry the
+ * fields whose value is specific to this configuration; everything else
+ * falls back to the field's own `default`.
+ */
+export interface TestConfiguration {
+    name: string;
+    label?: string;
+    description?: string;
+    defaults?: Record<string, unknown>;
+}
+
 export interface TestMethod {
     label?: string;
     description?: string;
@@ -89,6 +102,7 @@ export interface TestMethod {
     views?: Record<string, ChartView>;
     asset_refs?: AssetRef[];
     analysis?: AnalysisShape | null;
+    configurations?: TestConfiguration[];
     [key: string]: unknown; // tolerate unknown server-side fields
 }
 

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

@@ -87,6 +87,35 @@ export function validateMethod(methodId: string, m: TestMethod): ValidationError
         }
     }
 
+    // Configurations: name non-empty + unique, and every override key
+    // must name a real config_field. `knownConfigFields` is the subset of
+    // knownFields declared under config_fields specifically — overrides
+    // can only target config fields.
+    const configFieldNames = new Set<string>(
+        ((m.config_fields as TestField[] | undefined) ?? []).map(f => f.name).filter(Boolean),
+    );
+    const configs = (m.configurations as Array<any> | undefined) ?? [];
+    const seenConfig = new Set<string>();
+    configs.forEach((c, i) => {
+        const name = typeof c?.name === 'string' ? c.name.trim() : '';
+        if (!name) {
+            errs.push({ path: `configurations.${i}.name`, message: `${methodId}.configurations[${i}]: empty configuration name` });
+        } else if (seenConfig.has(name)) {
+            errs.push({ path: `configurations.${i}.name`, message: `${methodId}.configurations: duplicate configuration name "${name}"` });
+        } else {
+            seenConfig.add(name);
+        }
+        const defaults = (c?.defaults ?? {}) as Record<string, unknown>;
+        for (const key of Object.keys(defaults)) {
+            if (!configFieldNames.has(key)) {
+                errs.push({
+                    path: `configurations.${i}.defaults.${key}`,
+                    message: `${methodId}.configurations.${name || i}: override "${key}" does not match any config_field`,
+                });
+            }
+        }
+    });
+
     return errs;
 }
 

package/src/themes/adc-dark/_extensions.scss

@@ -215,6 +215,7 @@
     .ac-toolbar-group {
         display: flex;
         flex-direction: row;
+        align-items: center;
         gap: 2px;
     }
 
@@ -328,4 +329,23 @@
 
 .p-dialog .p-dialog-content {
     padding: 4mm !important;
+}
+
+
+/* Padding for fieldset */
+
+.p-fieldset {
+  .p-fieldset-legend {
+    padding: 0.5mm;
+  }
+
+  .p-fieldset-content {
+    padding: 1mm;
+  }
+
+  border-width: 0.5mm;
+
+  .p-fieldset-legend {
+    border-width: 0.5mm;
+  }
 }

package/src/themes/theme-base/components/panel/_fieldset.scss

@@ -5,7 +5,7 @@
     border-radius: $borderRadius;
 
     .p-fieldset-legend {
-        padding: $panelHeaderPadding;
+        padding: 0.5mm;
         border: $panelHeaderBorder;
         color: $panelHeaderTextColor;
         background: $panelHeaderBg;
@@ -42,6 +42,6 @@
     }
 
     .p-fieldset-content {
-        padding: $panelContentPadding;
+        padding: 1mm;
     }
 }