@adcops/autocore-react 3.5.3 → 3.5.7

package/src/components/ams/AssetDetailView.tsx

@@ -16,6 +16,7 @@ import { MessageType } from '../../hub/CommandMessage';
 import { useAms } from './AmsProvider';
 import { CalibrationEntryDialog } from './CalibrationEntryDialog';
 import { AssetEditDialog } from './AssetEditDialog';
+import { AssetNameplateGrid } from './AssetNameplateGrid';
 
 export const AssetDetailView: React.FC = () => {
     const { selection, schemas, roles, readAsset, listCalibrations, readCalibration, readUsage,
@@ -189,26 +190,7 @@ export const AssetDetailView: React.FC = () => {
             {schemaFields.length > 0 && (
                 <div>
                     <h4 style={{ margin: '0 0 0.5rem 0' }}>Nameplate</h4>
-                    <div style={{ display: 'grid', gridTemplateColumns: 'auto 1fr',
-                                  gap: '0.25rem 1rem', alignItems: 'baseline',
-                                  fontSize: '0.9rem' }}>
-                        {schemaFields.map((f: any) => {
-                            const v = custom[f.name];
-                            const present = v !== undefined && v !== null && v !== '';
-                            const label = f.label ?? f.name;
-                            const display = present
-                                ? (f.units ? `${v} ${f.units}` : String(v))
-                                : '(not set)';
-                            return (
-                                <React.Fragment key={f.name}>
-                                    <strong title={f.description ?? undefined}>{label}</strong>
-                                    <span style={{ color: present ? undefined : '#f59e0b' }}>
-                                        {display}
-                                    </span>
-                                </React.Fragment>
-                            );
-                        })}
-                    </div>
+                    <AssetNameplateGrid schemaFields={schemaFields} custom={custom} />
                 </div>
             )}
 

package/src/components/ams/AssetNameplateGrid.tsx

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * <AssetNameplateGrid> — the nameplate field/value grid for one asset.
+ *
+ * Extracted so <AssetDetailView> (the full record) and
+ * <InstalledAssetPicker> (what is fitted right now) render a nameplate the
+ * same way. A field the schema declares but the record has not filled in is
+ * drawn as an amber "(not set)" rather than blank space: that is exactly the
+ * state the placeholder resolver refuses to start a module on, so it is worth
+ * drawing the eye to.
+ */
+
+import React from 'react';
+
+export interface AssetNameplateGridProps {
+    /** The asset_type schema's `fields` array. */
+    schemaFields: any[];
+    /** The asset record's `custom` object (nameplate values). */
+    custom: Record<string, any>;
+    /** Only render these field names, in this order. Omit for all of them. */
+    only?: string[];
+    /** Font size for the grid; the detail view runs slightly larger. */
+    fontSize?: string;
+}
+
+export const AssetNameplateGrid: React.FC<AssetNameplateGridProps> = ({
+    schemaFields,
+    custom,
+    only,
+    fontSize = '0.9rem',
+}) => {
+    const fields = only
+        ? only
+              .map(name => schemaFields.find((f: any) => f.name === name))
+              .filter(Boolean)
+        : schemaFields;
+
+    if (fields.length === 0) return null;
+
+    return (
+        <div style={{ display: 'grid', gridTemplateColumns: 'auto 1fr',
+                      gap: '0.25rem 1rem', alignItems: 'baseline', fontSize }}>
+            {fields.map((f: any) => {
+                const v = custom[f.name];
+                const present = v !== undefined && v !== null && v !== '';
+                const label = f.label ?? f.name;
+                const display = present
+                    ? (f.units ? `${v} ${f.units}` : String(v))
+                    : '(not set)';
+                return (
+                    <React.Fragment key={f.name}>
+                        <strong title={f.description ?? undefined}>{label}</strong>
+                        <span style={{ color: present ? undefined : '#f59e0b' }}>
+                            {display}
+                        </span>
+                    </React.Fragment>
+                );
+            })}
+        </div>
+    );
+};

package/src/components/ams/AssetRegistryTable.tsx

@@ -164,6 +164,14 @@ export const AssetRegistryTable: React.FC = () => {
     const [filterType, setFilterType] = useState<string | null>(null);
     const [filterStatus, setFilterStatus] = useState<string | null>(null);
     const [addState, setAddState] = useState<AddDialogState>(EMPTY_ADD);
+    /** True from the moment Create is pressed until `ams.create_asset`
+     *  has answered and the registry has been refreshed. Creation is a
+     *  server round-trip, and with the buttons still live an operator
+     *  who saw no feedback would press Create again — registering the
+     *  same asset two or three times. While this is set the footer
+     *  shows a spinner instead of the buttons and the dialog refuses to
+     *  close, so there is no second press to swallow. */
+    const [creating, setCreating] = useState(false);
 
     // <MissingAssetsBanner> fires the `ams:prefill-add` custom event
     // when an operator clicks Register on one of its rows. Catch it
@@ -243,7 +251,10 @@ export const AssetRegistryTable: React.FC = () => {
     }, [assets, filterType, filterStatus]);
 
     const onCreate = async () => {
-        if (!addState.assetType) return;
+        // Re-entry guard: belt to the footer's braces. The footer hides
+        // the button while `creating`, but a queued click (or a stray
+        // Enter key) must not post a second create.
+        if (!addState.assetType || creating) return;
         // Coerce the per-field strings to their declared types. Numbers
         // become JSON numbers, bools become bools; empty strings drop
         // out so the asset_json doesn't get noisy with empty values.
@@ -296,6 +307,7 @@ export const AssetRegistryTable: React.FC = () => {
             payload.sub_locations = subLocations;
         }
 
+        setCreating(true);
         try {
             const resp: any = await invoke('ams.create_asset' as any, MessageType.Request, payload);
             if (resp?.success) {
@@ -309,6 +321,11 @@ export const AssetRegistryTable: React.FC = () => {
             }
         } catch (e) {
             console.error('[AssetRegistryTable] create_asset threw:', e);
+        } finally {
+            // Always clear, including on the failure paths above — the
+            // dialog stays open with the operator's entries intact and
+            // the buttons come back so they can retry or cancel.
+            setCreating(false);
         }
     };
 
@@ -466,15 +483,29 @@ export const AssetRegistryTable: React.FC = () => {
                 header="Add New Asset"
                 visible={addState.open}
                 style={{ width: '32rem' }}
-                onHide={() => setAddState(EMPTY_ADD)}
+                /* No escape hatches while the create is in flight: the
+                   header X, the Escape key and the mask click all route
+                   through onHide, and closing mid-flight would drop the
+                   operator back to a table that has not refreshed yet. */
+                closable={!creating}
+                closeOnEscape={!creating}
+                onHide={() => { if (!creating) setAddState(EMPTY_ADD); }}
                 footer={
-                    <>
-                        <Button label="Cancel" severity="secondary" onClick={() => setAddState(EMPTY_ADD)} />
-                        <Button label="Create" icon="pi pi-check"
-                            onClick={onCreate}
-                            disabled={createDisabled}
-                        />
-                    </>
+                    creating ? (
+                        <div style={{ display: 'flex', justifyContent: 'flex-end',
+                                      alignItems: 'center', gap: '0.5rem' }}>
+                            <i className="pi pi-spin pi-spinner" />
+                            <span>Creating asset…</span>
+                        </div>
+                    ) : (
+                        <>
+                            <Button label="Cancel" severity="secondary" onClick={() => setAddState(EMPTY_ADD)} />
+                            <Button label="Create" icon="pi pi-check"
+                                onClick={onCreate}
+                                disabled={createDisabled}
+                            />
+                        </>
+                    )
                 }
             >
                 <div style={{ display: 'grid', gridTemplateColumns: 'auto 1fr', gap: '0.5rem 1rem', alignItems: 'center' }}>

package/src/components/ams/InstalledAssetPicker.tsx

@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * <InstalledAssetPicker> — "which asset is fitted in this role right now?"
+ *
+ * The operator-facing answer to a swap. A machine with a 2 kN and a 20 kN load
+ * cell in the drawer has ONE of them bolted to the press; this picker is where
+ * they say which, and everything downstream — the test record's asset
+ * snapshot, module placeholders, the control program's AssetWatch — follows
+ * from that one statement.
+ *
+ * It writes through `ams.assign_role`, never two `ams.update_asset` calls: the
+ * server vacates the role and installs the replacement atomically, because
+ * `resolve_method_refs` takes the FIRST active asset it finds at a location and
+ * a momentarily double-claimed role would therefore resolve to an arbitrary one.
+ *
+ * Deliberately NOT a nameplate editor. The nameplate belongs to the asset
+ * record (Assets tab / <AssetDetailView>) — one source of truth. This picker
+ * only chooses which record is in force, and shows what that record says so the
+ * operator can confirm they grabbed the right hardware before pressing on.
+ */
+
+import React, { useCallback, useMemo, useState } from 'react';
+import { Dropdown } from 'primereact/dropdown';
+import { Button } from 'primereact/button';
+import { Dialog } from 'primereact/dialog';
+import { Message } from 'primereact/message';
+import { AssetNameplateGrid } from './AssetNameplateGrid';
+import { useInstalledAsset } from './useInstalledAsset';
+
+export interface InstalledAssetPickerProps {
+    /** Asset type the role takes, e.g. `"load_cell"`. */
+    assetType: string;
+    /** The role's `location` string, e.g. `"press_load_cell"`. */
+    location: string;
+    /**
+     * Heading for the picker. Defaults to the role's label from
+     * `ams.list_roles`, then to the raw location.
+     */
+    label?: string;
+    /** One line under the dropdown explaining what this role drives. */
+    description?: string;
+    /**
+     * Nameplate field names folded into each option's text, so the operator can
+     * tell two assets apart without opening them (e.g.
+     * `["capacity", "capacity_units"]` → "2000 N"). Serial is always shown.
+     */
+    summaryFields?: string[];
+    /** Render the fitted asset's full nameplate below the dropdown. */
+    showNameplate?: boolean;
+    /** Render the fitted asset's calibration state below the nameplate. */
+    showCalibration?: boolean;
+    /**
+     * Block the swap. Use for "a test is running" — changing the fitted asset
+     * mid-run would re-scale a channel under the data being recorded.
+     */
+    disabled?: boolean;
+    /** Why it is blocked. Shown in place of the help text. */
+    disabledReason?: string;
+    /** Fired after a successful assignment with the new asset id (or null). */
+    onAssigned?: (assetId: string | null) => void;
+}
+
+/** Option value standing for "nothing is fitted". */
+const NONE = '__none__';
+
+export const InstalledAssetPicker: React.FC<InstalledAssetPickerProps> = ({
+    assetType,
+    location,
+    label,
+    description,
+    summaryFields = [],
+    showNameplate = true,
+    showCalibration = true,
+    disabled = false,
+    disabledReason,
+    onAssigned,
+}) => {
+    const {
+        candidates, records, installed, installedRecord,
+        calibration, calibrationOverdue, role, schemaFields, assign,
+    } = useInstalledAsset(assetType, location);
+
+    const [error, setError] = useState<string | null>(null);
+    const [busy, setBusy] = useState(false);
+    /** Non-null while the confirm dialog is open; carries the pending choice. */
+    const [pending, setPending] = useState<{ assetId: string | null } | null>(null);
+
+    const roleLabel = label ?? role?.label ?? location;
+    const roleHelp  = description ?? role?.description ?? null;
+
+    /** "SN 4471-A — 2000 N" — enough to tell two assets apart in a list. */
+    const optionText = useCallback((assetId: string): string => {
+        const entry = candidates.find(c => c.asset_id === assetId);
+        const custom = (records[assetId]?.custom ?? {}) as Record<string, any>;
+        const bits: string[] = [entry?.serial ? `SN ${entry.serial}` : assetId];
+        const summary = summaryFields
+            .map(name => custom[name])
+            .filter(v => v !== undefined && v !== null && v !== '')
+            .join(' ');
+        if (summary) bits.push(summary);
+        return bits.join(' — ');
+    }, [candidates, records, summaryFields]);
+
+    const options = useMemo(() => [
+        ...candidates.map(c => ({ label: optionText(c.asset_id), value: c.asset_id })),
+        { label: '— nothing fitted —', value: NONE },
+    ], [candidates, optionText]);
+
+    const commit = async (assetId: string | null) => {
+        setBusy(true);
+        setError(null);
+        const err = await assign(assetId);
+        setBusy(false);
+        setPending(null);
+        if (err) { setError(err); return; }
+        onAssigned?.(assetId);
+    };
+
+    const calExpiry = calibration?.expires_at ? new Date(calibration.expires_at) : null;
+
+    return (
+        <div style={{ display: 'flex', flexDirection: 'column', gap: '0.5rem' }}>
+            <div className="p-inputgroup">
+                <span className="p-inputgroup-addon" style={{ flexGrow: 1 }}>
+                    {roleLabel}
+                </span>
+                <Dropdown
+                    value={installed?.asset_id ?? NONE}
+                    options={options}
+                    disabled={disabled || busy}
+                    onChange={(e) => {
+                        const next = e.value === NONE ? null : (e.value as string);
+                        if (next === (installed?.asset_id ?? null)) return;
+                        setPending({ assetId: next });
+                    }}
+                    placeholder="Select the fitted asset"
+                    style={{ minWidth: '18rem' }}
+                />
+            </div>
+
+            {/* Help text, or the reason the operator can't change it. On screen
+                rather than in a hover tooltip — this runs on a touchscreen,
+                where a tooltip is unreachable. */}
+            {disabled && disabledReason
+                ? <small style={{ color: '#f59e0b' }}>{disabledReason}</small>
+                : roleHelp && <small style={{ color: '#9ca3af' }}>{roleHelp}</small>}
+
+            {candidates.length === 0 && (
+                <Message severity="warn"
+                    text={`No active ${assetType.replace(/_/g, ' ')} is registered. Add one on the Assets screen first.`} />
+            )}
+
+            {!installed && candidates.length > 0 && (
+                <Message severity="warn"
+                    text="Nothing is recorded as fitted in this role. Tests that need it will refuse to start." />
+            )}
+
+            {error && <Message severity="error" text={error} />}
+
+            {installed && showNameplate && (
+                <AssetNameplateGrid
+                    schemaFields={schemaFields}
+                    custom={(installedRecord?.custom ?? {}) as Record<string, any>}
+                />
+            )}
+
+            {installed && showCalibration && (
+                <small style={{ color: calibrationOverdue ? '#f59e0b' : '#9ca3af' }}>
+                    {!installed.current_calibration_id
+                        ? 'No calibration on record for this asset.'
+                        : calibrationOverdue
+                            ? `Calibration ${installed.current_calibration_id} expired ${calExpiry!.toLocaleDateString()}.`
+                            : `Calibration ${installed.current_calibration_id}${
+                                calExpiry ? `, in date until ${calExpiry.toLocaleDateString()}` : ''}.`}
+                </small>
+            )}
+
+            {/* Confirm, because this restates what hardware is bolted to the
+                machine: downstream it re-scales a measurement channel and is
+                frozen into every test record started afterwards. */}
+            <Dialog
+                visible={pending !== null}
+                header={`Change the ${roleLabel}?`}
+                modal
+                onHide={() => setPending(null)}
+                footer={
+                    <>
+                        <Button label="Cancel" outlined onClick={() => setPending(null)} />
+                        <Button label="Confirm" loading={busy}
+                            onClick={() => { void commit(pending?.assetId ?? null); }} />
+                    </>
+                }
+            >
+                <p style={{ margin: 0 }}>
+                    {pending?.assetId
+                        ? <>Record <strong>{optionText(pending.assetId)}</strong> as the asset fitted
+                            in <strong>{roleLabel}</strong>.</>
+                        : <>Record that <strong>nothing</strong> is fitted in <strong>{roleLabel}</strong>.</>}
+                </p>
+                <p style={{ marginBottom: 0, color: '#9ca3af' }}>
+                    Confirm only if this matches the hardware actually installed. The
+                    machine reconfigures the channel from this asset's nameplate, and
+                    every test started from now on records it.
+                </p>
+            </Dialog>
+        </div>
+    );
+};

package/src/components/ams/index.ts

@@ -14,3 +14,10 @@ export { AssetEditDialog } from './AssetEditDialog';
 export { SubLocationPicker } from './SubLocationPicker';
 export { PlaceholderHealthPanel } from './PlaceholderHealthPanel';
 export { MissingAssetsBanner } from './MissingAssetsBanner';
+// "What is fitted right now" — the operator's swap surface, and the
+// nameplate grid it shares with <AssetDetailView>.
+export { InstalledAssetPicker } from './InstalledAssetPicker';
+export type { InstalledAssetPickerProps } from './InstalledAssetPicker';
+export { AssetNameplateGrid } from './AssetNameplateGrid';
+export { useInstalledAsset } from './useInstalledAsset';
+export type { InstalledAssetState } from './useInstalledAsset';

package/src/components/ams/useInstalledAsset.ts

@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * useInstalledAsset — "what is fitted in this role, and what does its record
+ * say?" for one (assetType, location) pair.
+ *
+ * The registry cache in <AmsProvider> carries only identity (id, serial,
+ * status, location); anything that has to show or act on a NAMEPLATE needs the
+ * full record. This hook is the one place that fetch happens, so
+ * <InstalledAssetPicker> and a product's own panel (e.g. a load-channel
+ * verification table comparing the nameplate against what the hardware
+ * actually holds) read the same data instead of each querying for it.
+ */
+
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useAms, type AmsAssetEntry, type AmsRole } from './AmsProvider';
+
+export interface InstalledAssetState {
+    /** Every ACTIVE asset of this type — the assets that could be fitted. */
+    candidates: AmsAssetEntry[];
+    /** Full records for `candidates`, keyed by asset_id. */
+    records: Record<string, any>;
+    /** The registry entry fitted in this role, or null when nothing is. */
+    installed: AmsAssetEntry | null;
+    /** The fitted asset's full record; nameplate values live under `.custom`. */
+    installedRecord: any | null;
+    /** The fitted asset's current calibration record, or null. */
+    calibration: any | null;
+    /** True once the calibration on record has passed its `expires_at`. */
+    calibrationOverdue: boolean;
+    /** This role's metadata from `ams.list_roles`, when the project declares it. */
+    role: AmsRole | null;
+    /** The asset_type schema's nameplate `fields` array (empty if unknown). */
+    schemaFields: any[];
+    /**
+     * Declare what is fitted (`null` = nothing). Resolves to `null` on success
+     * or the server's refusal message.
+     */
+    assign: (assetId: string | null) => Promise<string | null>;
+}
+
+export function useInstalledAsset(assetType: string, location: string): InstalledAssetState {
+    const { assets, schemas, roles, readAsset, readCalibration, assignRole } = useAms();
+
+    const [records, setRecords] = useState<Record<string, any>>({});
+    const [calibration, setCalibration] = useState<any | null>(null);
+
+    const candidates = useMemo(
+        () => assets.filter(a => a.asset_type === assetType && a.status === 'active'),
+        [assets, assetType],
+    );
+    const installed = useMemo(
+        () => candidates.find(a => a.location === location) ?? null,
+        [candidates, location],
+    );
+    const role = useMemo(
+        () => (roles[assetType] ?? []).find(r => r.location === location) ?? null,
+        [roles, assetType, location],
+    );
+
+    // Fetch the full record for every candidate. Keyed on the id list, so a
+    // registry refresh that left the candidate set alone does no I/O.
+    const candidateKey = candidates.map(c => c.asset_id).join(',');
+    useEffect(() => {
+        let cancelled = false;
+        (async () => {
+            const next: Record<string, any> = {};
+            for (const c of candidates) {
+                const rec = await readAsset(c.asset_id);
+                if (cancelled) return;
+                if (rec) next[c.asset_id] = rec;
+            }
+            if (!cancelled) setRecords(next);
+        })();
+        return () => { cancelled = true; };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [candidateKey, readAsset]);
+
+    // The fitted asset's current calibration, for the "is it in date?" line.
+    useEffect(() => {
+        let cancelled = false;
+        (async () => {
+            if (!installed?.current_calibration_id) { setCalibration(null); return; }
+            const cal = await readCalibration(installed.asset_id, installed.current_calibration_id);
+            if (!cancelled) setCalibration(cal);
+        })();
+        return () => { cancelled = true; };
+    }, [installed?.asset_id, installed?.current_calibration_id, readCalibration]);
+
+    const assign = useCallback(
+        (assetId: string | null) => assignRole(location, assetId),
+        [assignRole, location],
+    );
+
+    const expiry = calibration?.expires_at ? new Date(calibration.expires_at) : null;
+
+    return {
+        candidates,
+        records,
+        installed,
+        installedRecord: installed ? (records[installed.asset_id] ?? null) : null,
+        calibration,
+        calibrationOverdue: !!expiry && expiry.getTime() < Date.now(),
+        role,
+        schemaFields: Array.isArray(schemas[assetType]?.fields) ? schemas[assetType].fields : [],
+        assign,
+    };
+}

package/src/components/tis/TestFieldRow.tsx

@@ -181,6 +181,37 @@ export interface TagLookup {
 /** Matches a bound token like `${gm.press_force_min_n}` (whole-string). */
 const BOUND_TOKEN_RE = /^\$\{\s*([^}]+?)\s*\}$/;
 
+/** Is this string a well-formed FQDN bound token? */
+export const isBoundToken = (s: string): boolean => BOUND_TOKEN_RE.test(s.trim());
+
+/**
+ * Render a bound for an authoring text field — the method editor's Min/Max.
+ *
+ * A text field, not a numeric one, because a bound is a number OR a token. The
+ * editor used `InputNumber`, which rendered a token as **NaN** and — worse —
+ * coerced anything non-numeric to `undefined` on change, so opening the dialog
+ * and saving silently deleted a token bound.
+ */
+export const boundText = (b: number | string | undefined): string =>
+    b === undefined || b === null ? '' : String(b);
+
+/**
+ * Parse what an author typed into a bound field. Blank clears it; a finite
+ * number stores a number; anything else is kept VERBATIM so a half-typed token
+ * survives the keystroke. Use `boundInvalid` to flag what will not resolve.
+ */
+export const parseBound = (text: string): number | string | undefined => {
+    const t = text.trim();
+    if (t === '') return undefined;
+    const n = Number(t);
+    if (Number.isFinite(n)) return n;
+    return t;
+};
+
+/** True when a bound is a string that is not a well-formed token. */
+export const boundInvalid = (b: number | string | undefined): boolean =>
+    typeof b === 'string' && !isBoundToken(b);
+
 /**
  * A declared bound resolved to a plain DISPLAY-unit number, or `undefined` for
  * "no bound".