@adcops/autocore-react 3.5.9 → 3.5.13

package/src/hooks/useSequenceProducers.ts

@@ -0,0 +1,104 @@
+/**
+ * useSequenceProducers — the names a method's sequence actually records.
+ *
+ * A TIS cycle field has two possible producers and the method editor could only
+ * ever see one of them:
+ *
+ *  1. `source: "gm.<var>"` — the generated `add_cycle()` reads the tag.
+ *  2. `source: null` — the value arrives with the row, matched by NAME. On
+ *     gen4_ac that is the sequencer: `store_value` steps fill a row buffer and
+ *     `tis.add_cycle` writes `cycle_data` verbatim, without checking it against
+ *     `cycle_fields`.
+ *
+ * Because nothing checks the second one, both of its failure modes are silent:
+ * a declared column nothing stores is blank on every row forever, and a stored
+ * name with no column is recorded where nothing displays it. This hook reads
+ * the `.seq.json` so the editor can say so.
+ *
+ * The method id IS the sequence filename and the TIS method id — one name, set
+ * by the sequence workbench's New / Save As / Open. A product with no sequencer
+ * simply has no such file, which is why "could not read it" resolves to
+ * `undefined` and never to `[]`: an empty list would claim every cycle field
+ * has no producer.
+ */
+
+import { useCallback, useContext, useEffect, useRef, useState } from 'react';
+import { EventEmitterContext } from '../core/EventEmitterContext';
+import { MessageType } from '../hub/CommandMessage';
+
+/** Where the sequence library lives in the datastore. */
+const METHOD_DIR = 'methods';
+const METHOD_EXT = '.seq.json';
+
+export interface UseSequenceProducersOptions {
+    /** Override the IPC layer (tests, playground). */
+    invoker?: (topic: string, messageType: number, payload: object) => Promise<any>;
+}
+
+export interface UseSequenceProducersResult {
+    /** `store_value` names, or `undefined` when there is no sequence to read. */
+    producedNames: string[] | undefined;
+    loading: boolean;
+    refresh: () => Promise<void>;
+}
+
+/** Every `store_value` name in a method, `cycle` bodies included. */
+export function collectStoredNames(method: any): string[] {
+    const out: string[] = [];
+    const walk = (steps: any[]) => {
+        if (!Array.isArray(steps)) return;
+        for (const s of steps) {
+            if (!s || typeof s !== 'object') continue;
+            if (s.type === 'cycle') walk(s.body);
+            // A repeated measurement lives inside a `cycle` body, so a walk that
+            // stopped at the top level would miss exactly the methods that
+            // record the most.
+            if (s.type === 'store_value' && typeof s.name === 'string' && s.name.trim() !== '') {
+                if (!out.includes(s.name)) out.push(s.name);
+            }
+        }
+    };
+    walk(method?.steps);
+    return out;
+}
+
+export function useSequenceProducers(
+    methodId: string | null,
+    options?: UseSequenceProducersOptions,
+): UseSequenceProducersResult {
+    const ctx = useContext(EventEmitterContext);
+    const invoke = options?.invoker
+        ?? ((topic: string, messageType: number, payload: object) =>
+            ctx.invoke(topic as any, messageType as any, payload as any));
+
+    const invokeRef = useRef(invoke);
+    invokeRef.current = invoke;
+
+    const [producedNames, setProducedNames] = useState<string[] | undefined>(undefined);
+    const [loading, setLoading] = useState<boolean>(false);
+
+    const refresh = useCallback(async () => {
+        if (!methodId) { setProducedNames(undefined); return; }
+        setLoading(true);
+        try {
+            const topic = `datastore.${METHOD_DIR}/${methodId}${METHOD_EXT}`;
+            const resp: any = await invokeRef.current(topic, MessageType.Read, {});
+            if (resp?.success === false) { setProducedNames(undefined); return; }
+            const method = resp?.data ?? resp;
+            // Only a method-shaped object counts. A read that returns something
+            // else is "no sequence", not "a sequence storing nothing".
+            if (!method || !Array.isArray(method.steps)) { setProducedNames(undefined); return; }
+            setProducedNames(collectStoredNames(method));
+        } catch {
+            setProducedNames(undefined);
+        } finally {
+            setLoading(false);
+        }
+    }, [methodId]);
+
+    useEffect(() => { void refresh(); }, [refresh]);
+
+    return { producedNames, loading, refresh };
+}
+
+export default useSequenceProducers;