@tangle-network/sandbox-ui 0.3.6 → 0.3.10

package/dist/chunk-OEX7NZE3.js

@@ -0,0 +1,321 @@
+// 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

@@ -0,0 +1,61 @@
+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
+};