@adcops/autocore-react 3.6.7 → 3.6.10

package/src/components/ams/AssetRegistryTable.tsx

@@ -15,6 +15,9 @@ import { Dialog } from 'primereact/dialog';
 import { EventEmitterContext } from '../../core/EventEmitterContext';
 import { MessageType } from '../../hub/CommandMessage';
 import { useAms, type AmsAssetEntry, type AmsRole } from './AmsProvider';
+import {
+    type SchemaField, SchemaFieldInput, coerceField, fieldLabel,
+} from './schemaField';
 import './AssetRegistryTable.css';
 
 // Sentinel value for the "Other..." dropdown option, which lets the
@@ -76,14 +79,6 @@ function roleUsageSummary(r: AmsRole): string {
 /** Render-ready descriptor for one schema-declared field. Schemas come
  *  back from `ams.list_schemas` as untyped JSON; this narrows the
  *  fields we actually care about for the Add dialog. */
-interface SchemaField {
-    name: string;
-    type: string;
-    units?: string;
-    label?: string;
-    description?: string;
-    required?: boolean;
-}
 
 /** The keyed-fields sub_locations schema declared on an asset_type
  *  (multi-axis transducers etc.). `keys` fixes the row set; `fields`
@@ -138,24 +133,6 @@ function seedCustomFromRoleDefaults(
     return out;
 }
 
-/** Coerce a per-cell string from the matrix input back to its declared
- *  type. Numeric strings → JSON numbers; booleans → bool; everything
- *  else stays as a string. Matches the top-level fields coercion. */
-function coerceField(field: SchemaField, raw: string): any {
-    if (raw === undefined || raw === '') return undefined;
-    switch (field.type) {
-        case 'f32': case 'f64':
-        case 'i8': case 'i16': case 'i32': case 'i64':
-        case 'u8': case 'u16': case 'u32': case 'u64': {
-            const n = Number(raw);
-            return Number.isFinite(n) ? n : undefined;
-        }
-        case 'bool':
-            return raw === 'true' || raw === '1';
-        default:
-            return raw;
-    }
-}
 
 export const AssetRegistryTable: React.FC = () => {
     const { schemas, roles, assets, refreshAssets, setSelection, selection } = useAms();
@@ -559,44 +536,21 @@ export const AssetRegistryTable: React.FC = () => {
                         are what the placeholder resolver reads to seed
                         NI bridge channels and EL3356 SDOs. Required
                         fields gate Create. */}
-                    {fieldsForType.map(field => {
-                        const label = field.label ?? field.name;
-                        const fullLabel = field.units
-                            ? `${label} [${field.units}]${field.required ? ' *' : ''}`
-                            : `${label}${field.required ? ' *' : ''}`;
-                        const isNum = field.type !== 'string' && field.type !== 'bool';
-                        return (
-                            <React.Fragment key={field.name}>
-                                <label title={field.description ?? undefined}>
-                                    {fullLabel}
-                                </label>
-                                {field.type === 'bool' ? (
-                                    <Dropdown
-                                        value={addState.customFields[field.name] ?? ''}
-                                        options={[
-                                            { label: 'true',  value: 'true' },
-                                            { label: 'false', value: 'false' },
-                                        ]}
-                                        onChange={(e) => setAddState(s => ({
-                                            ...s,
-                                            customFields: { ...s.customFields, [field.name]: e.value },
-                                        }))}
-                                        placeholder="—"
-                                    />
-                                ) : (
-                                    <InputText
-                                        value={addState.customFields[field.name] ?? ''}
-                                        keyfilter={isNum ? 'num' : undefined}
-                                        placeholder={field.description ?? undefined}
-                                        onChange={(e) => setAddState(s => ({
-                                            ...s,
-                                            customFields: { ...s.customFields, [field.name]: e.target.value },
-                                        }))}
-                                    />
-                                )}
-                            </React.Fragment>
-                        );
-                    })}
+                    {fieldsForType.map(field => (
+                        <React.Fragment key={field.name}>
+                            <label title={field.description ?? undefined}>
+                                {fieldLabel(field)}
+                            </label>
+                            <SchemaFieldInput
+                                field={field}
+                                value={addState.customFields[field.name] ?? ''}
+                                onChange={(v) => setAddState(s => ({
+                                    ...s,
+                                    customFields: { ...s.customFields, [field.name]: v },
+                                }))}
+                            />
+                        </React.Fragment>
+                    ))}
                 </div>
 
                 {/* Per-axis matrix for asset types with a keyed-fields
@@ -643,16 +597,13 @@ export const AssetRegistryTable: React.FC = () => {
                                             {subLocationsSchema.fields.map(field => {
                                                 const cellValue =
                                                     addState.subLocationFields[key]?.[field.name] ?? '';
-                                                const isNum =
-                                                    field.type !== 'string' && field.type !== 'bool';
                                                 return (
                                                     <td key={field.name}
                                                         style={{ padding: '0.25rem 0.5rem' }}>
-                                                        <InputText
+                                                        <SchemaFieldInput
+                                                            field={field}
                                                             value={cellValue}
-                                                            keyfilter={isNum ? 'num' : undefined}
-                                                            onChange={(e) => {
-                                                                const v = e.target.value;
+                                                            onChange={(v) => {
                                                                 setAddState(s => ({
                                                                     ...s,
                                                                     subLocationFields: {

package/src/components/ams/index.ts

@@ -19,5 +19,10 @@ export { MissingAssetsBanner } from './MissingAssetsBanner';
 export { InstalledAssetPicker } from './InstalledAssetPicker';
 export type { InstalledAssetPickerProps } from './InstalledAssetPicker';
 export { AssetNameplateGrid } from './AssetNameplateGrid';
+// One schema field: its shape, how a form value is coerced back to its
+// declared type, and the input control that edits it. Shared so a field can
+// gain a behaviour (a dropdown, say) in one place rather than in each form.
+export { SchemaFieldInput, coerceField, fieldChoices, fieldLabel, isNumericField } from './schemaField';
+export type { SchemaField, FieldOption, Choice, SchemaFieldInputProps } from './schemaField';
 export { useInstalledAsset } from './useInstalledAsset';
 export type { InstalledAssetState } from './useInstalledAsset';

package/src/components/ams/schemaField.tsx

@@ -0,0 +1,166 @@
+/**
+ * @file
+ * One asset-schema field: its shape, how a typed value is coerced out of the
+ * string the form holds, and the input control that edits it.
+ *
+ * Every AMS form renders the same thing in seven places — the asset create
+ * form, the asset edit form, the per-axis sub-location matrix in each of those,
+ * the per-axis calibration matrix, the flat calibration values, and the
+ * standalone calibration dialog. They had drifted into seven copies of the same
+ * `label ?? name` / `[units]` / `*` / bool-Dropdown-else-InputText block, plus
+ * three copies of `SchemaField` and two of `coerceField`.
+ *
+ * That duplication is why a field could not gain a behaviour: adding one meant
+ * finding all seven. `capacity_units` is the case that forced this — it is a
+ * free-text string today, so an operator typed "Newtons" where the consuming
+ * machine matched on "N", and the fix is a dropdown in every one of those
+ * places or it is not a fix.
+ */
+
+import React from 'react';
+import { Dropdown } from 'primereact/dropdown';
+import { InputText } from 'primereact/inputtext';
+
+/**
+ * One choice in a field's dropdown, as authored in the asset-type schema.
+ *
+ * Mirrors `FieldOption` in autocore-ams's `config.rs`: either a bare scalar,
+ * where the stored value and the operator-facing label are the same, or an
+ * explicit pair when they should differ.
+ *
+ * ```jsonc
+ * "options": ["N", "kN", "lbf"]
+ * "options": [{ "label": "Newtons (N)", "value": "N" }]
+ * ```
+ */
+export type FieldOption =
+    | string
+    | number
+    | boolean
+    | { label: string; value: unknown };
+
+/** One field of an asset type's `fields` / `calibration_fields` schema. */
+export interface SchemaField {
+    name: string;
+    type: string;
+    units?: string;
+    label?: string;
+    description?: string;
+    required?: boolean;
+    /** Fixed set of choices. When present the field is a dropdown, not a
+     *  free-form input — see the file header. */
+    options?: FieldOption[];
+}
+
+/** A choice normalised for PrimeReact's `Dropdown`. */
+export interface Choice {
+    label: string;
+    value: string;
+}
+
+/**
+ * The choices this field offers, or `null` if it is free-form.
+ *
+ * Booleans are a fixed two-choice dropdown, as they always were. An explicit
+ * `options` list wins over the type's own rendering, which is what lets a
+ * `string` field be constrained without inventing a new type.
+ *
+ * Values are carried as STRINGS because that is what the form state holds;
+ * `coerceField` converts back on submit.
+ */
+export function fieldChoices(field: SchemaField): Choice[] | null {
+    if (field.options && field.options.length > 0) {
+        return field.options.map((opt) =>
+            opt !== null && typeof opt === 'object' && 'value' in opt
+                ? { label: String(opt.label), value: String(opt.value) }
+                : { label: String(opt), value: String(opt) });
+    }
+    if (field.type === 'bool') {
+        return [
+            { label: 'true', value: 'true' },
+            { label: 'false', value: 'false' },
+        ];
+    }
+    return null;
+}
+
+/** True when the field takes digits only, so the input can keyfilter. A field
+ *  with `options` is never free-typed, so it never keyfilters. */
+export function isNumericField(field: SchemaField): boolean {
+    if (fieldChoices(field)) return false;
+    return field.type !== 'string' && field.type !== 'bool';
+}
+
+/**
+ * Coerce the form's string back to the field's declared type.
+ *
+ * Numeric strings become JSON numbers and booleans become bools, because the
+ * placeholder resolver and the SDO writers downstream expect native types — a
+ * string `"5000"` does not satisfy a `${ams.*}` reference asking for a numeric
+ * `max_val`. Empty stays `undefined` so an untouched field is omitted from the
+ * record rather than stored blank.
+ */
+export function coerceField(field: SchemaField, raw: string | undefined): any {
+    if (raw === undefined || raw === '') return undefined;
+    switch (field.type) {
+        case 'f32': case 'f64':
+        case 'i8': case 'i16': case 'i32': case 'i64':
+        case 'u8': case 'u16': case 'u32': case 'u64': {
+            const n = Number(raw);
+            return Number.isFinite(n) ? n : undefined;
+        }
+        case 'bool':
+            return raw === 'true' || raw === '1';
+        default:
+            return raw;
+    }
+}
+
+/** The label a form shows for this field: pretty name, units, required mark. */
+export function fieldLabel(field: SchemaField): string {
+    const base = field.label ?? field.name;
+    const req = field.required ? ' *' : '';
+    return field.units ? `${base} [${field.units}]${req}` : `${base}${req}`;
+}
+
+export interface SchemaFieldInputProps {
+    field: SchemaField;
+    /** Current value, as the string the form state holds. */
+    value: string;
+    /** Called with the new string. Coercion happens on submit, not here. */
+    onChange: (next: string) => void;
+    style?: React.CSSProperties;
+}
+
+/**
+ * The input control for one schema field: a dropdown when the field has a
+ * fixed set of choices, a text box otherwise.
+ *
+ * Deliberately uncontrolled about layout — callers place it in a grid or a
+ * table cell — so this owns only the decision that must be the same everywhere.
+ */
+export const SchemaFieldInput: React.FC<SchemaFieldInputProps> = ({
+    field, value, onChange, style,
+}) => {
+    const choices = fieldChoices(field);
+    if (choices) {
+        return (
+            <Dropdown
+                value={value ?? ''}
+                options={choices}
+                onChange={(e) => onChange(e.value)}
+                placeholder="—"
+                style={style}
+            />
+        );
+    }
+    return (
+        <InputText
+            value={value ?? ''}
+            keyfilter={isNumericField(field) ? 'num' : undefined}
+            placeholder={field.description ?? undefined}
+            onChange={(e) => onChange(e.target.value)}
+            style={style}
+        />
+    );
+};

package/src/components/tis/ResultHistoryTable.css

@@ -1,12 +1,25 @@
-/* Runs excluded from cross-test aggregation are kept visible but dimmed and
-   struck through, so an operator can see at a glance which rows don't feed
-   the avg/min/max/stddev/count results for their sample group. */
+/* Runs excluded from cross-test aggregation are kept visible but dimmed, so an
+   operator can see at a glance which rows don't feed the avg/min/max/stddev/
+   count results for their sample group. The row's Status column says the word
+   "Excluded" outright, and its Details dialog says what that means — the dim
+   is a scanning aid, never the only signal.
+
+   NO line-through. It used to be here and it read as "deleted": an excluded
+   run is intact, still downloadable, and one click from being counted again.
+
+   Nor is there an exception rule for the action buttons. There was one —
+   `.tis-row-excluded > td .p-button { opacity: 1; text-decoration: none }` —
+   and neither half of it could ever have worked, because both properties come
+   from the ancestor `td`:
+
+     • `opacity` on the td composites its whole subtree as one group. A
+       descendant's `opacity: 1` cannot escape an ancestor's 0.55.
+     • `text-decoration` propagates from an ancestor to its in-flow
+       descendants and cannot be cancelled by a descendant at all.
+
+   So anything that must be exempt has to be exempt at the td: put the effect
+   on the text cells, not on every cell. Kept as one rule here because 0.55
+   leaves the buttons legible and they are what the operator reaches for. */
 .tis-row-excluded > td {
     opacity: 0.55;
-    text-decoration: line-through;
-}
-/* Keep the action buttons (Include / Download) legible and clickable. */
-.tis-row-excluded > td .p-button {
-    opacity: 1;
-    text-decoration: none;
 }