@checkstack/ui 1.3.4 → 1.3.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @checkstack/ui
 
+## 1.3.6
+
+### Patch Changes
+
+- 4b0934d: Refactored UserMenu to use a responsive grid layout, improved menu item alignment, and implemented a full-screen scrollable portal for mobile devices. Fixed an issue where the UserMenu would instantly close and reopen when clicking the trigger while the menu was open.
+
+## 1.3.5
+
+### Patch Changes
+
+- 286491a: Added automatic FPS detection that enables "Low Power Mode" once for devices running below 50 FPS, ensuring smooth performance even for users unaware of the manual toggle.
+
 ## 1.3.4
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@checkstack/ui",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "type": "module",
   "main": "src/index.ts",
   "dependencies": {
@@ -21,18 +21,20 @@
     "monaco-editor": "^0.55.1",
     "react": "^18.2.0",
     "react-day-picker": "^9.13.0",
+    "react-dom": "^19.2.5",
     "react-markdown": "^10.1.0",
     "react-router-dom": "^6.20.0",
     "recharts": "^3.6.0",
     "tailwind-merge": "^2.2.0"
   },
   "devDependencies": {
-    "typescript": "^5.0.0",
-    "@types/react": "^18.2.0",
-    "@testing-library/react": "^16.0.0",
+    "@checkstack/scripts": "0.1.2",
     "@checkstack/test-utils-frontend": "0.0.4",
     "@checkstack/tsconfig": "0.0.5",
-    "@checkstack/scripts": "0.1.2"
+    "@testing-library/react": "^16.0.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^19.2.3",
+    "typescript": "^5.0.0"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",

package/src/components/DropdownMenu.tsx

@@ -1,11 +1,43 @@
-import React, { useRef, useEffect } from "react";
+import React, { useRef, useEffect, createContext, useContext, useState } from "react";
+import { createPortal } from "react-dom";
+import { X } from "lucide-react";
 import { cn } from "../utils";
 import { usePerformance } from "./PerformanceProvider";
 
+export const DropdownMenuContext = createContext<{ onClose?: () => void }>({});
+
+/**
+ * Custom hook to detect mobile viewport.
+ */
+export function useIsMobile() {
+  const [isMobile, setIsMobile] = useState(false);
+
+  useEffect(() => {
+    // Initial check
+    const mql = globalThis.matchMedia("(max-width: 640px)");
+    setIsMobile(mql.matches);
+
+    // Listener for changes
+    const handler = (e: MediaQueryListEvent) => setIsMobile(e.matches);
+    mql.addEventListener("change", handler);
+    return () => mql.removeEventListener("change", handler);
+  }, []);
+
+  return isMobile;
+}
+
+
+export const DropdownMenuRootContext = createContext<{ rootRef?: React.RefObject<HTMLDivElement> }>({});
+
 export const DropdownMenu: React.FC<{ children: React.ReactNode }> = ({
   children,
 }) => {
-  return <div className="relative inline-block text-left">{children}</div>;
+  const rootRef = useRef<HTMLDivElement>(null);
+  return (
+    <DropdownMenuRootContext.Provider value={{ rootRef }}>
+      <div ref={rootRef} className="relative inline-block text-left">{children}</div>
+    </DropdownMenuRootContext.Provider>
+  );
 };
 
 export const DropdownMenuTrigger: React.FC<{
@@ -25,44 +57,83 @@ export const DropdownMenuContent: React.FC<{
   isOpen: boolean;
   onClose: () => void;
   className?: string;
-}> = ({ children, isOpen, onClose, className }) => {
+  innerClassName?: string;
+}> = ({ children, isOpen, onClose, className, innerClassName }) => {
   const { isLowPower } = usePerformance();
   const contentRef = useRef<HTMLDivElement>(null);
+  const { rootRef } = useContext(DropdownMenuRootContext);
+  const isMobile = useIsMobile();
 
   useEffect(() => {
     const handleClickOutside = (event: MouseEvent) => {
-      if (
-        contentRef.current &&
-        !contentRef.current.contains(event.target as Node)
-      ) {
-        onClose();
+      // Don't auto-close if clicking outside on mobile (full screen modal style)
+      if (isMobile) return;
+      
+      const target = event.target as Node;
+      
+      // Don't close if clicking inside the menu content
+      if (contentRef.current && contentRef.current.contains(target)) {
+        return;
+      }
+      
+      // Don't close if clicking inside the wrapper (e.g. the trigger button)
+      // This allows the trigger's onClick to handle toggling the menu without conflict.
+      if (rootRef?.current && rootRef.current.contains(target)) {
+        return;
       }
+      
+      onClose();
     };
 
     if (isOpen) {
       document.addEventListener("mousedown", handleClickOutside);
+      // Lock body scroll on mobile
+      if (isMobile) {
+        document.body.style.overflow = "hidden";
+      }
     }
     return () => {
       document.removeEventListener("mousedown", handleClickOutside);
+      if (isMobile) {
+        document.body.style.overflow = "";
+      }
     };
-  }, [isOpen, onClose]);
+  }, [isOpen, onClose, isMobile, rootRef]);
 
   if (!isOpen) return <React.Fragment />;
 
-  return (
+  const content = (
     <div
       ref={contentRef}
       className={cn(
-        "absolute right-0 mt-2 w-56 origin-top-right rounded-md bg-popover shadow-lg ring-1 ring-border focus:outline-none z-[100]",
+        isMobile
+          ? "fixed inset-0 z-[100] bg-background w-full h-full p-4 overflow-y-auto"
+          : "absolute right-0 mt-2 w-56 origin-top-right rounded-md bg-popover shadow-lg ring-1 ring-border focus:outline-none z-[100] max-h-[calc(100vh-4rem)] overflow-y-auto",
         !isLowPower && "animate-in fade-in zoom-in-95 duration-100",
         className
       )}
     >
-      <div className="py-1" role="none">
-        {children}
-      </div>
+      <DropdownMenuContext.Provider value={{ onClose }}>
+        <div className={cn(isMobile ? "flex flex-col pt-4 pb-12" : "py-1", innerClassName)} role="none">
+          {isMobile && (
+            <div className="flex justify-between items-center mb-6 col-span-full px-2">
+              <h2 className="text-xl font-bold text-foreground">Menu</h2>
+              <button 
+                onClick={onClose} 
+                className="p-2 rounded-full hover:bg-accent text-muted-foreground transition-colors"
+                aria-label="Close menu"
+              >
+                <X className="w-6 h-6" />
+              </button>
+            </div>
+          )}
+          {children}
+        </div>
+      </DropdownMenuContext.Provider>
     </div>
   );
+
+  return isMobile ? createPortal(content, document.body) : content;
 };
 
 export const DropdownMenuItem: React.FC<{
@@ -70,30 +141,47 @@ export const DropdownMenuItem: React.FC<{
   onClick?: () => void;
   className?: string;
   icon?: React.ReactNode;
-}> = ({ children, onClick, className, icon }) => {
+  description?: React.ReactNode;
+  closeOnClick?: boolean;
+}> = ({ children, onClick, className, icon, description, closeOnClick = true }) => {
+  const { onClose } = useContext(DropdownMenuContext);
+
+  const handleClick = () => {
+    if (onClick) onClick();
+    if (closeOnClick && onClose) onClose();
+  };
+
   return (
     <button
-      onClick={onClick}
+      onClick={handleClick}
       className={cn(
-        "flex items-center w-full px-4 py-2 text-sm text-popover-foreground hover:bg-accent hover:text-accent-foreground transition-colors",
+        "flex flex-col items-start w-full px-4 py-2 text-sm text-popover-foreground hover:bg-accent hover:text-accent-foreground transition-colors rounded-sm overflow-hidden",
         className
       )}
       role="menuitem"
     >
-      {icon && <span className="mr-3 text-muted-foreground">{icon}</span>}
-      {children}
+      <div className="flex items-center w-full overflow-hidden">
+        {icon && <span className="mr-3 text-muted-foreground shrink-0">{icon}</span>}
+        <span className="flex-1 text-left truncate">{children}</span>
+      </div>
+      {description && (
+        <span className={cn("text-[10px] text-muted-foreground mt-1 leading-tight text-left truncate w-full", icon ? "pl-7" : "")}>
+          {description}
+        </span>
+      )}
     </button>
   );
 };
 
-export const DropdownMenuSeparator: React.FC = () => (
-  <div className="my-1 h-px bg-border" />
+export const DropdownMenuSeparator: React.FC<{ className?: string }> = ({ className }) => (
+  <div className={cn("my-1 h-px bg-border col-span-full", className)} />
 );
 
-export const DropdownMenuLabel: React.FC<{ children: React.ReactNode }> = ({
+export const DropdownMenuLabel: React.FC<{ children: React.ReactNode; className?: string }> = ({
   children,
+  className
 }) => (
-  <div className="px-4 py-2 text-xs font-semibold text-muted-foreground uppercase tracking-wider">
+  <div className={cn("px-4 py-2 text-xs font-semibold text-muted-foreground uppercase tracking-wider col-span-full", className)}>
     {children}
   </div>
 );

package/src/components/PerformanceProvider.tsx

@@ -1,9 +1,10 @@
 import React, { createContext, useContext, useEffect, useState } from "react";
+import { useToast } from "./ToastProvider";
 
 const STORAGE_KEY = "checkstack-low-power";
 
 interface PerformanceContextValue {
-  /** 
+  /**
    * Whether the application should run in low-power mode.
    * Derived from (manualLowPower || prefersReducedMotion).
    */
@@ -38,9 +39,13 @@ interface PerformanceProviderProps {
  * Supports manual override (persisted to localStorage) and respects OS-level
  * Reduced Motion preferences.
  */
-export const PerformanceProvider: React.FC<PerformanceProviderProps> = ({ children }) => {
+export const PerformanceProvider: React.FC<PerformanceProviderProps> = ({
+  children,
+}) => {
+  const toast = useToast();
   const [manualLowPower, setManualLowPower] = useState<boolean>(false);
-  const [prefersReducedMotion, setPrefersReducedMotion] = useState<boolean>(false);
+  const [prefersReducedMotion, setPrefersReducedMotion] =
+    useState<boolean>(false);
   const [isLoaded, setIsLoaded] = useState<boolean>(false);
 
   useEffect(() => {
@@ -51,11 +56,14 @@ export const PerformanceProvider: React.FC<PerformanceProviderProps> = ({ childr
     }
 
     // 2. Initialize Reduced Motion Detection
-    const mediaQuery = globalThis.matchMedia("(prefers-reduced-motion: reduce)");
+    const mediaQuery = globalThis.matchMedia(
+      "(prefers-reduced-motion: reduce)",
+    );
     setPrefersReducedMotion(mediaQuery.matches);
 
     // 3. Listen for changes in OS-level settings
-    const listener = (e: MediaQueryListEvent) => setPrefersReducedMotion(e.matches);
+    const listener = (e: MediaQueryListEvent) =>
+      setPrefersReducedMotion(e.matches);
     mediaQuery.addEventListener("change", listener);
 
     setIsLoaded(true);
@@ -63,6 +71,61 @@ export const PerformanceProvider: React.FC<PerformanceProviderProps> = ({ childr
     return () => mediaQuery.removeEventListener("change", listener);
   }, []);
 
+  useEffect(() => {
+    // 4. Automatic FPS Detection (Runs once per device)
+    const stored = globalThis.localStorage?.getItem(STORAGE_KEY);
+    if (stored !== null) return; // User already has a saved preference, don't auto-detect
+
+    let rAFId: number;
+    let isCancelled = false;
+
+    // Wait 1 second for initial render and hydration to settle
+    const warmupTimer = setTimeout(() => {
+      if (isCancelled) return;
+
+      let frameCount = 0;
+      let startTime = performance.now();
+
+      const measure = (time: DOMHighResTimeStamp) => {
+        if (isCancelled) return;
+        if (frameCount === 0) startTime = time;
+        frameCount++;
+        const elapsed = time - startTime;
+
+        if (elapsed >= 1000) {
+          const fps = (frameCount * 1000) / elapsed;
+          if (fps < 50) {
+            setManualLowPower(true);
+            globalThis.localStorage?.setItem(STORAGE_KEY, "true");
+            toast.info(
+              "Low power mode was automatically activated to improve performance. Hardware acceleration appears to be disabled.",
+              8000
+            );
+            console.warn(
+              `[PerformanceProvider] Auto-enabled Low Power Mode. Detected FPS: ${fps.toFixed(1)}`,
+            );
+          } else {
+            // Save 'false' to prevent future auto-detection checks
+            globalThis.localStorage?.setItem(STORAGE_KEY, "false");
+            console.log(
+              `[PerformanceProvider] Performance OK. Detected FPS: ${fps.toFixed(1)}`,
+            );
+          }
+        } else {
+          rAFId = globalThis.requestAnimationFrame(measure);
+        }
+      };
+
+      rAFId = globalThis.requestAnimationFrame(measure);
+    }, 1000);
+
+    return () => {
+      isCancelled = true;
+      clearTimeout(warmupTimer);
+      if (rAFId) globalThis.cancelAnimationFrame(rAFId);
+    };
+  }, [toast]);
+
   const toggleManualLowPower = () => {
     setManualLowPower((prev) => {
       const next = !prev;

package/src/components/UserMenu.tsx

@@ -60,7 +60,12 @@ export const UserMenu: React.FC<UserMenuProps> = ({
         </button>
       </DropdownMenuTrigger>
 
-      <DropdownMenuContent isOpen={isOpen} onClose={() => setIsOpen(false)}>
+      <DropdownMenuContent 
+        isOpen={isOpen} 
+        onClose={() => setIsOpen(false)}
+        className="w-full sm:w-[400px] md:w-[460px]"
+        innerClassName="grid grid-cols-1 sm:grid-cols-2 p-2 gap-2 sm:gap-1"
+      >
         <DropdownMenuLabel>
           <div className="flex flex-col">
             <span className="text-sm font-bold text-foreground truncate">