@tangle-network/ui 11.9.0 → 11.11.0

package/dist/chunk-OEX7NZE3.js

@@ -1,321 +0,0 @@
-// src/stores/active-sessions-store.ts
-import { useStore } from "@nanostores/react";
-import { atom } from "nanostores";
-import { useMemo } from "react";
-var INITIAL_STATE = {
-  sessions: {},
-  lastUpdatedAt: 0
-};
-var STATUS_PRIORITY = {
-  running: 0,
-  error: 1,
-  "attention-needed": 2,
-  idle: 3
-};
-var DEFAULT_RECORD = {
-  status: "idle",
-  isRunning: false,
-  isForeground: false,
-  needsAttention: false,
-  connectionState: "disconnected",
-  reconnectState: "idle",
-  transportMode: null,
-  lastError: null,
-  lastEventAt: null
-};
-var activeSessionsAtom = atom(INITIAL_STATE);
-var foregroundSessionId = null;
-function createRecord(options, now) {
-  return {
-    sessionId: options.sessionId,
-    projectId: options.projectId ?? null,
-    projectLabel: options.projectLabel,
-    title: options.title,
-    href: options.href,
-    registeredAt: now,
-    lastActivityAt: now,
-    metadata: options.metadata,
-    ...DEFAULT_RECORD,
-    isForeground: options.sessionId === foregroundSessionId
-  };
-}
-function resolveStatus(session) {
-  if (session.isRunning) return "running";
-  if (session.lastError || session.reconnectState === "failed") return "error";
-  if (session.needsAttention) return "attention-needed";
-  return "idle";
-}
-function normalizeSession(session) {
-  return {
-    ...session,
-    status: resolveStatus(session)
-  };
-}
-function updateSession(sessionId, updater) {
-  const current = activeSessionsAtom.get();
-  const existing = current.sessions[sessionId];
-  if (!existing) return;
-  const now = Date.now();
-  activeSessionsAtom.set({
-    sessions: {
-      ...current.sessions,
-      [sessionId]: normalizeSession(updater(existing, now))
-    },
-    lastUpdatedAt: now
-  });
-}
-function registerActiveSession(options) {
-  const now = Date.now();
-  const current = activeSessionsAtom.get();
-  const existing = current.sessions[options.sessionId];
-  activeSessionsAtom.set({
-    sessions: {
-      ...current.sessions,
-      [options.sessionId]: normalizeSession(
-        existing ? {
-          ...existing,
-          projectId: existing.projectId ?? options.projectId ?? null,
-          projectLabel: options.projectLabel ?? existing.projectLabel,
-          title: options.title ?? existing.title,
-          href: options.href ?? existing.href,
-          metadata: options.metadata ?? existing.metadata,
-          lastActivityAt: now,
-          isForeground: options.sessionId === foregroundSessionId || existing.isForeground
-        } : createRecord(options, now)
-      )
-    },
-    lastUpdatedAt: now
-  });
-}
-function unregisterActiveSession(sessionId) {
-  const current = activeSessionsAtom.get();
-  if (!current.sessions[sessionId]) return;
-  const { [sessionId]: _removed, ...remaining } = current.sessions;
-  if (foregroundSessionId === sessionId) {
-    foregroundSessionId = null;
-  }
-  activeSessionsAtom.set({
-    sessions: remaining,
-    lastUpdatedAt: Date.now()
-  });
-}
-function setForegroundActiveSession(sessionId) {
-  foregroundSessionId = sessionId;
-  const current = activeSessionsAtom.get();
-  const now = Date.now();
-  let changed = false;
-  const sessions = Object.fromEntries(
-    Object.entries(current.sessions).map(([id, session]) => {
-      const isForeground = id === sessionId;
-      if (session.isForeground !== isForeground) {
-        changed = true;
-      }
-      return [
-        id,
-        {
-          ...session,
-          isForeground,
-          lastActivityAt: isForeground ? now : session.lastActivityAt
-        }
-      ];
-    })
-  );
-  if (!changed) return;
-  activeSessionsAtom.set({
-    sessions,
-    lastUpdatedAt: now
-  });
-}
-function updateActiveSessionMeta(sessionId, meta) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    ...meta,
-    lastActivityAt: now
-  }));
-}
-function setActiveSessionConnection(sessionId, options) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    connectionState: options.connectionState,
-    reconnectState: options.reconnectState ?? session.reconnectState,
-    transportMode: options.transportMode ?? session.transportMode,
-    lastError: options.lastError === void 0 ? session.lastError : options.lastError,
-    lastEventAt: options.lastEventAt ?? session.lastEventAt,
-    lastActivityAt: now
-  }));
-}
-function setActiveSessionRunning(sessionId, isRunning, options) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    isRunning,
-    needsAttention: isRunning ? false : session.needsAttention,
-    lastError: isRunning ? null : session.lastError,
-    lastEventAt: options?.lastEventAt ?? session.lastEventAt,
-    lastActivityAt: now
-  }));
-}
-function setActiveSessionAttention(sessionId, needsAttention, options) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    needsAttention,
-    isRunning: needsAttention ? false : session.isRunning,
-    lastEventAt: options?.lastEventAt ?? session.lastEventAt,
-    lastActivityAt: now
-  }));
-}
-function setActiveSessionError(sessionId, error) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    isRunning: false,
-    needsAttention: false,
-    lastError: error,
-    reconnectState: error ? "failed" : "idle",
-    connectionState: error ? "error" : session.connectionState,
-    lastEventAt: now,
-    lastActivityAt: now
-  }));
-}
-function bumpActiveSessionActivity(sessionId, options) {
-  updateSession(sessionId, (session, now) => ({
-    ...session,
-    lastEventAt: options?.lastEventAt ?? session.lastEventAt ?? now,
-    lastActivityAt: now
-  }));
-}
-function resetActiveSessions() {
-  foregroundSessionId = null;
-  activeSessionsAtom.set(INITIAL_STATE);
-}
-function getAllActiveSessions(state) {
-  return Object.values(state.sessions);
-}
-function getActiveSession(state, sessionId) {
-  return state.sessions[sessionId] ?? null;
-}
-function getSessionsForProject(state, projectId) {
-  return Object.values(state.sessions).filter((session) => session.projectId === projectId);
-}
-function getSessionsForNavbar(state, projectId) {
-  const sessions = projectId == null ? Object.values(state.sessions) : getSessionsForProject(state, projectId);
-  return [...sessions].sort((left, right) => {
-    if (left.isForeground !== right.isForeground) {
-      return Number(right.isForeground) - Number(left.isForeground);
-    }
-    const statusDiff = STATUS_PRIORITY[left.status] - STATUS_PRIORITY[right.status];
-    if (statusDiff !== 0) {
-      return statusDiff;
-    }
-    return right.lastActivityAt - left.lastActivityAt;
-  });
-}
-function getSessionsByActivity(state) {
-  return [...Object.values(state.sessions)].sort(
-    (left, right) => right.lastActivityAt - left.lastActivityAt
-  );
-}
-function getTotalRunningSessionCount(state) {
-  return Object.values(state.sessions).filter((session) => session.isRunning).length;
-}
-function hasBackgroundRunningSessions(state) {
-  return Object.values(state.sessions).some(
-    (session) => session.isRunning && !session.isForeground
-  );
-}
-function getAllProjectActivity(state) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const session of Object.values(state.sessions)) {
-    if (session.projectId == null) continue;
-    const existing = grouped.get(session.projectId);
-    if (existing) {
-      existing.activeSessionCount += 1;
-      existing.lastActivityAt = Math.max(existing.lastActivityAt, session.lastActivityAt);
-      if (session.isRunning) {
-        existing.runningSessionIds.push(session.sessionId);
-      }
-      if (!existing.projectLabel && session.projectLabel) {
-        existing.projectLabel = session.projectLabel;
-      }
-      continue;
-    }
-    grouped.set(session.projectId, {
-      projectId: session.projectId,
-      projectLabel: session.projectLabel,
-      activeSessionCount: 1,
-      runningSessionIds: session.isRunning ? [session.sessionId] : [],
-      lastActivityAt: session.lastActivityAt
-    });
-  }
-  return [...grouped.values()].sort((left, right) => right.lastActivityAt - left.lastActivityAt);
-}
-function useActiveSessionsState() {
-  return useStore(activeSessionsAtom);
-}
-function useActiveSessions() {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => getAllActiveSessions(state), [state]);
-}
-function useActiveSession(sessionId) {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(
-    () => sessionId ? getActiveSession(state, sessionId) : null,
-    [sessionId, state]
-  );
-}
-function useProjectSessions(projectId) {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(
-    () => projectId == null ? [] : getSessionsForProject(state, projectId),
-    [projectId, state]
-  );
-}
-function useNavbarSessions(projectId) {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => getSessionsForNavbar(state, projectId), [projectId, state]);
-}
-function useSessionsByActivity() {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => getSessionsByActivity(state), [state]);
-}
-function useProjectActivity() {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => getAllProjectActivity(state), [state]);
-}
-function useTotalRunningSessions() {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => getTotalRunningSessionCount(state), [state]);
-}
-function useHasBackgroundRunningSessions() {
-  const state = useStore(activeSessionsAtom);
-  return useMemo(() => hasBackgroundRunningSessions(state), [state]);
-}
-
-export {
-  activeSessionsAtom,
-  registerActiveSession,
-  unregisterActiveSession,
-  setForegroundActiveSession,
-  updateActiveSessionMeta,
-  setActiveSessionConnection,
-  setActiveSessionRunning,
-  setActiveSessionAttention,
-  setActiveSessionError,
-  bumpActiveSessionActivity,
-  resetActiveSessions,
-  getAllActiveSessions,
-  getActiveSession,
-  getSessionsForProject,
-  getSessionsForNavbar,
-  getSessionsByActivity,
-  getTotalRunningSessionCount,
-  hasBackgroundRunningSessions,
-  getAllProjectActivity,
-  useActiveSessionsState,
-  useActiveSessions,
-  useActiveSession,
-  useProjectSessions,
-  useNavbarSessions,
-  useSessionsByActivity,
-  useProjectActivity,
-  useTotalRunningSessions,
-  useHasBackgroundRunningSessions
-};

package/dist/chunk-Q56BYXQF.js

@@ -1,61 +0,0 @@
-import {
-  cn
-} from "./chunk-RQHJBTEU.js";
-
-// src/primitives/tabs.tsx
-import * as TabsPrimitive from "@radix-ui/react-tabs";
-import * as React from "react";
-import { jsx } from "react/jsx-runtime";
-var Tabs = TabsPrimitive.Root;
-var TabsList = React.forwardRef(({ className, variant = "default", ...props }, ref) => {
-  const variants = {
-    default: "inline-flex h-10 items-center justify-center rounded-lg bg-muted p-1 text-muted-foreground",
-    pills: "inline-flex items-center gap-2",
-    underline: "inline-flex items-center gap-4 border-b border-border"
-  };
-  return /* @__PURE__ */ jsx(
-    TabsPrimitive.List,
-    {
-      ref,
-      className: cn(variants[variant], className),
-      ...props
-    }
-  );
-});
-TabsList.displayName = TabsPrimitive.List.displayName;
-var TabsTrigger = React.forwardRef(({ className, variant = "default", ...props }, ref) => {
-  const variants = {
-    default: "inline-flex items-center justify-center whitespace-nowrap rounded-md px-3 py-1.5 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:bg-background data-[state=active]:text-foreground data-[state=active]:shadow-sm",
-    pills: "inline-flex items-center justify-center whitespace-nowrap rounded-full px-4 py-2 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:bg-primary data-[state=active]:text-primary-foreground data-[state=inactive]:text-muted-foreground data-[state=inactive]:hover:bg-muted",
-    underline: "inline-flex items-center justify-center whitespace-nowrap pb-3 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 border-b-2 border-transparent data-[state=active]:border-primary data-[state=active]:text-foreground data-[state=inactive]:text-muted-foreground"
-  };
-  return /* @__PURE__ */ jsx(
-    TabsPrimitive.Trigger,
-    {
-      ref,
-      className: cn(variants[variant], className),
-      ...props
-    }
-  );
-});
-TabsTrigger.displayName = TabsPrimitive.Trigger.displayName;
-var TabsContent = React.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsx(
-  TabsPrimitive.Content,
-  {
-    ref,
-    className: cn(
-      "mt-4 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
-      "data-[state=active]:fade-in-0 data-[state=active]:slide-in-from-bottom-2 data-[state=active]:animate-in",
-      className
-    ),
-    ...props
-  }
-));
-TabsContent.displayName = TabsPrimitive.Content.displayName;
-
-export {
-  Tabs,
-  TabsList,
-  TabsTrigger,
-  TabsContent
-};

package/dist/chunk-REJESC5U.js

@@ -1,117 +0,0 @@
-// src/hooks/use-live-time.ts
-import * as React from "react";
-function useLiveTime(intervalMs = 1e3) {
-  const [now, setNow] = React.useState(() => Date.now());
-  React.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-auth.ts
-import * as React2 from "react";
-function useAuth({
-  apiBaseUrl,
-  revalidateOnFocus = false,
-  shouldRetryOnError = false
-}) {
-  const [user, setUser] = React2.useState(null);
-  const [isLoading, setIsLoading] = React2.useState(true);
-  const [error, setError] = React2.useState(null);
-  const retryTimerRef = React2.useRef(null);
-  const abortRef = React2.useRef(null);
-  const fetchSession = React2.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]);
-  React2.useEffect(() => {
-    fetchSession();
-    return () => {
-      abortRef.current?.abort();
-      if (retryTimerRef.current) clearTimeout(retryTimerRef.current);
-    };
-  }, [fetchSession]);
-  React2.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] = React2.useState(null);
-  React2.useEffect(() => {
-    if (typeof window !== "undefined") {
-      setApiKey(localStorage.getItem("apiKey"));
-    }
-  }, []);
-  return apiKey;
-}
-
-export {
-  useLiveTime,
-  useAuth,
-  createAuthFetcher,
-  useApiKey
-};