@tangle-network/sandbox-ui 0.13.0 → 0.15.1

package/dist/chunk-DPGIXDAI.js

@@ -1,220 +0,0 @@
-// src/hooks/use-auth.ts
-import * as React from "react";
-function useAuth({
-  apiBaseUrl,
-  revalidateOnFocus = false,
-  shouldRetryOnError = false
-}) {
-  const [user, setUser] = React.useState(null);
-  const [isLoading, setIsLoading] = React.useState(true);
-  const [error, setError] = React.useState(null);
-  const retryTimerRef = React.useRef(null);
-  const abortRef = React.useRef(null);
-  const fetchSession = React.useCallback(async () => {
-    abortRef.current?.abort();
-    const controller = new AbortController();
-    abortRef.current = controller;
-    setIsLoading(true);
-    setError(null);
-    try {
-      const res = await fetch(`${apiBaseUrl}/auth/session`, {
-        credentials: "include",
-        signal: controller.signal
-      });
-      if (!res.ok) {
-        throw new Error("Not authenticated");
-      }
-      const data = await res.json();
-      if (data.success && data.data) {
-        setUser(data.data);
-      } else {
-        setUser(null);
-      }
-    } catch (err) {
-      if (err.name === "AbortError") return;
-      setError(err instanceof Error ? err : new Error("Unknown error"));
-      setUser(null);
-      if (shouldRetryOnError) {
-        if (retryTimerRef.current) clearTimeout(retryTimerRef.current);
-        retryTimerRef.current = setTimeout(fetchSession, 5e3);
-      }
-    } finally {
-      if (!controller.signal.aborted) {
-        setIsLoading(false);
-      }
-    }
-  }, [apiBaseUrl, shouldRetryOnError]);
-  React.useEffect(() => {
-    fetchSession();
-    return () => {
-      abortRef.current?.abort();
-      if (retryTimerRef.current) clearTimeout(retryTimerRef.current);
-    };
-  }, [fetchSession]);
-  React.useEffect(() => {
-    if (!revalidateOnFocus) return;
-    const handleFocus = () => {
-      fetchSession();
-    };
-    window.addEventListener("focus", handleFocus);
-    return () => window.removeEventListener("focus", handleFocus);
-  }, [revalidateOnFocus, fetchSession]);
-  return {
-    user,
-    isLoading,
-    isError: !!error,
-    error,
-    mutate: fetchSession
-  };
-}
-function createAuthFetcher(_apiBaseUrl) {
-  return async function authFetcher(url, options) {
-    const res = await fetch(url, {
-      ...options,
-      credentials: "include",
-      headers: {
-        ...options?.headers
-      }
-    });
-    if (!res.ok) {
-      throw new Error(`Request failed with status ${res.status}`);
-    }
-    return res.json();
-  };
-}
-function useApiKey() {
-  const [apiKey, setApiKey] = React.useState(null);
-  React.useEffect(() => {
-    if (typeof window !== "undefined") {
-      setApiKey(localStorage.getItem("apiKey"));
-    }
-  }, []);
-  return apiKey;
-}
-
-// src/hooks/use-live-time.ts
-import * as React2 from "react";
-function useLiveTime(intervalMs = 1e3) {
-  const [now, setNow] = React2.useState(() => Date.now());
-  React2.useEffect(() => {
-    const requested = Number.isFinite(intervalMs) && intervalMs > 0 ? intervalMs : 1e3;
-    const delay = Math.max(requested, 100);
-    const id = window.setInterval(() => {
-      setNow(Date.now());
-    }, delay);
-    return () => {
-      window.clearInterval(id);
-    };
-  }, [intervalMs]);
-  return now;
-}
-
-// src/hooks/use-sandbox-metrics.ts
-import * as React3 from "react";
-function useSandboxMetrics({
-  apiBaseUrl,
-  sandboxId,
-  token,
-  enabled = true,
-  intervalMs = 3e3
-}) {
-  const [metrics, setMetrics] = React3.useState(null);
-  const [loading, setLoading] = React3.useState(false);
-  const [error, setError] = React3.useState(null);
-  const [lastUpdatedAt, setLastUpdatedAt] = React3.useState(null);
-  const sampleRef = React3.useRef(null);
-  const hasLoadedRef = React3.useRef(false);
-  const prevSandboxIdRef = React3.useRef(null);
-  React3.useEffect(() => {
-    const sandboxCleared = !sandboxId || !apiBaseUrl;
-    const sandboxChanged = prevSandboxIdRef.current !== null && prevSandboxIdRef.current !== sandboxId;
-    if (sandboxCleared && prevSandboxIdRef.current !== null || sandboxChanged) {
-      sampleRef.current = null;
-      hasLoadedRef.current = false;
-      setMetrics(null);
-      setLastUpdatedAt(null);
-      setError(null);
-      if (sandboxCleared) setLoading(false);
-    }
-    prevSandboxIdRef.current = sandboxId ?? null;
-    if (!enabled || sandboxCleared) {
-      return;
-    }
-    const controller = new AbortController();
-    let cancelled = false;
-    let timeoutId = null;
-    const delay = Math.max(intervalMs, 500);
-    const fetchOnce = async () => {
-      if (!hasLoadedRef.current) setLoading(true);
-      try {
-        const headers = {};
-        if (token) headers.Authorization = `Bearer ${token}`;
-        const res = await fetch(
-          `${apiBaseUrl}/v1/sidecar-proxy/${encodeURIComponent(sandboxId)}/metrics/json`,
-          {
-            method: "GET",
-            credentials: "include",
-            headers,
-            signal: controller.signal
-          }
-        );
-        if (!res.ok) {
-          throw new Error(`Metrics request failed (HTTP ${res.status})`);
-        }
-        const data = await res.json();
-        const user = data?.process?.cpuSeconds?.user ?? 0;
-        const system = data?.process?.cpuSeconds?.system ?? 0;
-        const cpuSeconds = user + system;
-        const wallMs = Date.now();
-        if (cancelled) return;
-        let cpuPercent = null;
-        const prev = sampleRef.current;
-        if (prev && prev.sandboxId === sandboxId) {
-          const dCpu = cpuSeconds - prev.cpuSeconds;
-          const dWallSec = (wallMs - prev.wallMs) / 1e3;
-          if (dWallSec > 0 && dCpu >= 0) {
-            cpuPercent = dCpu / dWallSec * 100;
-          }
-        }
-        sampleRef.current = { cpuSeconds, wallMs, sandboxId };
-        setMetrics({
-          cpuPercent,
-          rssBytes: data?.process?.memoryBytes?.rss ?? 0,
-          heapUsedBytes: data?.process?.memoryBytes?.heapUsed ?? 0,
-          heapTotalBytes: data?.process?.memoryBytes?.heapTotal ?? 0
-        });
-        setLastUpdatedAt(wallMs);
-        setError(null);
-        hasLoadedRef.current = true;
-        setLoading(false);
-      } catch (err) {
-        if (cancelled || err instanceof DOMException && err.name === "AbortError") {
-          return;
-        }
-        setError(err instanceof Error ? err : new Error(String(err)));
-        if (!hasLoadedRef.current) setLoading(false);
-      }
-    };
-    const runLoop = async () => {
-      if (cancelled) return;
-      await fetchOnce();
-      if (cancelled) return;
-      timeoutId = window.setTimeout(runLoop, delay);
-    };
-    runLoop();
-    return () => {
-      cancelled = true;
-      controller.abort();
-      if (timeoutId !== null) window.clearTimeout(timeoutId);
-    };
-  }, [apiBaseUrl, sandboxId, token, enabled, intervalMs]);
-  return { metrics, loading, error, lastUpdatedAt };
-}
-
-export {
-  useAuth,
-  createAuthFetcher,
-  useApiKey,
-  useLiveTime,
-  useSandboxMetrics
-};