@aixnn/aixautots 0.0.0-stage → 0.5.2

package/dist/chunk-SUKFJ73W.js

@@ -0,0 +1,217 @@
+import { DeviceChannel, ScriptDebugger } from './chunk-GKEPMDXO.js';
+import { resolveConfig, AixClient, EnvRun } from './chunk-PCYERBNZ.js';
+import React, { createContext, useContext, useState, useRef, useEffect, useMemo, useCallback } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var Ctx = createContext(null);
+function AixProvider({ config, children }) {
+  const resolved = React.useMemo(
+    () => resolveConfig(config),
+    // Spread individual stable primitives so an inline config object literal
+    // doesn't thrash the channel on every parent render.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [config.baseUrl, config.getAuthToken, config.fetchFn, config.wsFactory]
+  );
+  return /* @__PURE__ */ jsx(Ctx.Provider, { value: resolved, children });
+}
+function useAixConfig() {
+  const c = useContext(Ctx);
+  if (!c) throw new Error("useAixConfig must be used within <AixProvider>");
+  return c;
+}
+function useDevice(deviceId) {
+  const cfg = useAixConfig();
+  const [channel, setChannel] = useState(null);
+  const [error, setError] = useState(null);
+  const ref = useRef(null);
+  useEffect(() => {
+    let cancelled = false;
+    setChannel(null);
+    setError(null);
+    DeviceChannel.open(cfg, deviceId).then((ch) => {
+      if (cancelled) {
+        ch.close();
+        return;
+      }
+      ref.current = ch;
+      setChannel(ch);
+    }).catch((e) => {
+      if (!cancelled) setError(e instanceof Error ? e : new Error(String(e)));
+    });
+    return () => {
+      cancelled = true;
+      ref.current?.close();
+      ref.current = null;
+    };
+  }, [cfg, deviceId]);
+  return { deviceId, channel, error };
+}
+function useScript(deviceId, opts) {
+  const { channel, error: openError } = useDevice(deviceId);
+  const [running, setRunning] = useState(false);
+  const [runId, setRunId] = useState(null);
+  const [events, setEvents] = useState([]);
+  const [error, setError] = useState(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const dbg = useMemo(
+    () => channel ? new ScriptDebugger({ engine: opts.engine, channel }) : null,
+    [channel, opts.engine]
+  );
+  useEffect(() => {
+    if (!dbg) return;
+    const unsub = dbg.on("event", (e) => {
+      if (mountedRef.current) setEvents((prev) => [...prev, e]);
+    });
+    return () => {
+      unsub();
+      void dbg.cancel().catch(() => {
+      });
+      if (mountedRef.current) {
+        setRunning(false);
+        setRunId(null);
+      }
+    };
+  }, [dbg]);
+  const run = useCallback(async (input) => {
+    if (!dbg) throw new Error("device channel not ready");
+    if (mountedRef.current) {
+      setError(null);
+      setEvents([]);
+    }
+    try {
+      const res = await dbg.run(input);
+      if (mountedRef.current) {
+        setRunId(res.runId);
+        setRunning(true);
+      }
+      return res;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      if (mountedRef.current) setError(err);
+      throw err;
+    }
+  }, [dbg]);
+  const call = useCallback(async (method, args) => {
+    if (!dbg) throw new Error("device channel not ready");
+    return dbg.call(method, args);
+  }, [dbg]);
+  const cancel = useCallback(async () => {
+    if (!dbg) return;
+    await dbg.cancel();
+    if (mountedRef.current) {
+      setRunning(false);
+      setRunId(null);
+    }
+  }, [dbg]);
+  const clearEvents = useCallback(() => {
+    if (mountedRef.current) setEvents([]);
+  }, []);
+  return { ready: channel !== null, running, runId, events, error: error ?? openError, run, call, cancel, clearEvents };
+}
+function useClient() {
+  const cfg = useAixConfig();
+  return useMemo(() => new AixClient(cfg), [cfg]);
+}
+function useQuery(loader, deps) {
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const mounted = useRef(true);
+  const loaderRef = useRef(loader);
+  loaderRef.current = loader;
+  const run = useCallback(async () => {
+    if (mounted.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const r = await loaderRef.current();
+      if (mounted.current) {
+        setData(r);
+        setLoading(false);
+      }
+    } catch (e) {
+      if (mounted.current) {
+        setError(e instanceof Error ? e : new Error(String(e)));
+        setLoading(false);
+      }
+    }
+  }, deps);
+  useEffect(() => {
+    mounted.current = true;
+    void run();
+    return () => {
+      mounted.current = false;
+    };
+  }, [run]);
+  const patch = useCallback((updater) => {
+    if (mounted.current) setData((prev) => updater(prev));
+  }, []);
+  return { data, loading, error, refetch: run, setData: patch };
+}
+function useEnvRun() {
+  const cfg = useAixConfig();
+  const [reqId, setReqId] = useState(null);
+  const [events, setEvents] = useState([]);
+  const [finished, setFinished] = useState(null);
+  const [done, setDone] = useState(false);
+  const [error, setError] = useState(null);
+  const runRef = useRef(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      runRef.current?.close();
+      runRef.current = null;
+    };
+  }, []);
+  const run = useCallback(
+    async (start) => {
+      runRef.current?.close();
+      if (mountedRef.current) {
+        setError(null);
+        setEvents([]);
+        setFinished(null);
+        setDone(false);
+        setReqId(null);
+      }
+      try {
+        const r = await start();
+        runRef.current = r;
+        r.on("event", (e) => {
+          if (mountedRef.current) setEvents((prev) => [...prev, e]);
+        });
+        r.on("done", (f) => {
+          if (mountedRef.current) {
+            setFinished(f);
+            setDone(true);
+          }
+        });
+        if (mountedRef.current) setReqId(r.reqId);
+        return { reqId: r.reqId };
+      } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
+        if (mountedRef.current) setError(err);
+        throw err;
+      }
+    },
+    []
+  );
+  const setup = useCallback((nodeId, input) => run(() => EnvRun.start(cfg, nodeId, "setup", input)), [cfg, run]);
+  const status = useCallback((nodeId, input) => run(() => EnvRun.start(cfg, nodeId, "status", input)), [cfg, run]);
+  const teardown = useCallback((nodeId, input) => run(() => EnvRun.start(cfg, nodeId, "teardown", input)), [cfg, run]);
+  const close = useCallback(() => {
+    runRef.current?.close();
+    runRef.current = null;
+  }, []);
+  return { reqId, events, finished, done, error, setup, status, teardown, close };
+}
+
+export { AixProvider, useAixConfig, useClient, useDevice, useEnvRun, useQuery, useScript };