reflex 0.7.14a5__py3-none-any.whl → 0.8.0__py3-none-any.whl

reflex/.templates/web/utils/client_side_routing.js

@@ -1,41 +1,43 @@
 import { useEffect, useRef, useState } from "react";
-import { useRouter } from "next/router";
+import { useLocation, useNavigate } from "react-router-dom";
 
 /**
- * React hook for use in /404 page to enable client-side routing.
+ * React hook for use in NotFound page to enable client-side routing.
  *
- * Uses the next/router to redirect to the provided URL when loading
- * the 404 page (for example as a fallback in static hosting situations).
+ * Uses React Router to redirect to the provided URL when loading
+ * the NotFound page (for example as a fallback in static hosting situations).
  *
  * @returns {boolean} routeNotFound - true if the current route is an actual 404
  */
 export const useClientSideRouting = () => {
   const [routeNotFound, setRouteNotFound] = useState(false);
   const didRedirect = useRef(false);
-  const router = useRouter();
+  const location = useLocation();
+  const navigate = useNavigate();
+
   useEffect(() => {
-    if (
-      router.isReady &&
-      !didRedirect.current // have not tried redirecting yet
-    ) {
-      didRedirect.current = true; // never redirect twice to avoid "Hard Navigate" error
+    if (!didRedirect.current) {
+      // have not tried redirecting yet
+      didRedirect.current = true; // never redirect twice to avoid navigation loops
+
       // attempt to redirect to the route in the browser address bar once
-      router
-        .replace({
-          pathname: window.location.pathname,
-          query: window.location.search.slice(1),
-        })
+      const path = window.location.pathname;
+      const search = window.location.search;
+
+      // Use navigate instead of replace
+      navigate(path + search, { replace: true, state: { fromNotFound: true } })
         .then(() => {
-          // Check if the current route is /404
-          if (router.pathname === "/404") {
+          // Check if we're still on a NotFound route
+          // Note: This depends on how your routes are set up
+          if (location.pathname === path) {
             setRouteNotFound(true); // Mark as an actual 404
           }
         })
-        .catch((e) => {
+        .catch(() => {
           setRouteNotFound(true); // navigation failed, so this is a real 404
         });
     }
-  }, [router.isReady]);
+  }, [location, navigate]);
 
   // Return the reactive bool, to avoid flashing 404 page until we know for sure
   // the route is not found.

reflex/.templates/web/utils/react-theme.js

@@ -0,0 +1,92 @@
+import {
+  createContext,
+  useContext,
+  useState,
+  useEffect,
+  createElement,
+  useRef,
+  useMemo,
+} from "react";
+
+import { isDevMode, defaultColorMode } from "$/utils/context";
+
+const ThemeContext = createContext({
+  theme: defaultColorMode,
+  resolvedTheme: defaultColorMode !== "system" ? defaultColorMode : "light",
+  setTheme: () => {},
+});
+
+export function ThemeProvider({ children, defaultTheme = "system" }) {
+  const [theme, setTheme] = useState(defaultTheme);
+  const [systemTheme, setSystemTheme] = useState(
+    defaultTheme !== "system" ? defaultTheme : "light",
+  );
+
+  const firstRender = useRef(true);
+
+  useEffect(() => {
+    if (!firstRender.current) {
+      return;
+    }
+
+    firstRender.current = false;
+
+    if (isDevMode) {
+      const lastCompiledTheme = localStorage.getItem("last_compiled_theme");
+      if (lastCompiledTheme !== defaultColorMode) {
+        // on app startup, make sure the application color mode is persisted correctly.
+        localStorage.setItem("last_compiled_theme", defaultColorMode);
+        return;
+      }
+    }
+
+    // Load saved theme from localStorage
+    const savedTheme = localStorage.getItem("theme") || defaultTheme;
+    setTheme(savedTheme);
+  });
+
+  const resolvedTheme = useMemo(
+    () => (theme === "system" ? systemTheme : theme),
+    [theme, systemTheme],
+  );
+
+  useEffect(() => {
+    // Set up media query for system preference detection
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+
+    // Listen for system preference changes
+    const handleChange = () => {
+      setSystemTheme(mediaQuery.matches ? "dark" : "light");
+    };
+
+    handleChange();
+
+    mediaQuery.addEventListener("change", handleChange);
+
+    return () => {
+      mediaQuery.removeEventListener("change", handleChange);
+    };
+  });
+
+  // Save theme to localStorage whenever it changes
+  useEffect(() => {
+    localStorage.setItem("theme", theme);
+  }, [theme]);
+
+  useEffect(() => {
+    const root = window.document.documentElement;
+    root.classList.remove("light", "dark");
+    root.classList.add(resolvedTheme);
+    root.style.colorScheme = resolvedTheme;
+  }, [resolvedTheme]);
+
+  return createElement(
+    ThemeContext.Provider,
+    { value: { theme, resolvedTheme, setTheme } },
+    children,
+  );
+}
+
+export function useTheme() {
+  return useContext(ThemeContext);
+}