miolo-react 3.0.0-beta.166 → 3.0.0-beta.168

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miolo-react",
-  "version": "3.0.0-beta.166",
+  "version": "3.0.0-beta.168",
   "description": "React utils for miolo",
   "author": "Donato Lorenzo <donato@afialapis.com>",
   "contributors": [

package/src/index.mjs

@@ -3,4 +3,4 @@ import AppServer from "./AppServer.jsx"
 import useMioloContext from "./context/useMioloContext.jsx"
 import withMioloContext from "./context/withMioloContext.jsx"
 
-export { withMioloContext, useMioloContext, AppBrowser, AppServer }
+export { AppBrowser, AppServer, useMioloContext, withMioloContext }

package/src/ssr/useSsrDataOrReload.mjs

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from "react"
+import { useCallback, useEffect, useMemo, useRef, useState } from "react"
 import getSsrDataFromContext from "./getSsrDataFromContext.mjs"
 
 const useSsrDataOrReload = (context, miolo, name, options) => {
@@ -13,7 +13,14 @@ const useSsrDataOrReload = (context, miolo, name, options) => {
     model = undefined
   } = options
 
-  const _parseData = useCallback(
+  const prevLoader = useRef(loader)
+  const prevEffect = useRef(effect)
+  const loaderChangeCount = useRef(0)
+  const effectChangeCount = useRef(0)
+  const loaderChangeTime = useRef(0)
+  const effectChangeTime = useRef(0)
+
+  const parseData = useCallback(
     (value) => {
       let parsed = value
       if (model !== undefined) {
@@ -27,58 +34,109 @@ const useSsrDataOrReload = (context, miolo, name, options) => {
     [modifier, model]
   )
 
-  const ssrDataFromContext = getSsrDataFromContext(context, name)
+  const ssrDataFromContext = useMemo(() => {
+    return getSsrDataFromContext(context, name)
+  }, [context, name])
+
   const [ssrData, setSsrData] = useState(
-    _parseData(ssrDataFromContext !== undefined ? ssrDataFromContext : defval)
+    parseData(ssrDataFromContext !== undefined ? ssrDataFromContext : defval)
   )
 
-  const [needToRefresh, setNeedToRefresh] = useState(ssrDataFromContext === undefined)
-  const [status, setStatus] = useState(needToRefresh ? "idle" : "loaded")
+  const [status, setStatus] = useState(ssrDataFromContext !== undefined ? "loaded" : "idle")
   const [error, setError] = useState(undefined)
 
+  const updateSsrData = useCallback(
+    (data) => {
+      setStatus("loading")
+      setSsrData(parseData(data))
+      setStatus("loaded")
+      setError(undefined)
+    },
+    [parseData]
+  )
+
   const refreshSsrData = useCallback(async () => {
+    if (status === "loading") {
+      return
+    }
+
     setStatus("loading")
+    setError(undefined)
+
     if (loader !== undefined) {
       const nSsrData = await loader(context, fetcher)
-      setSsrData(_parseData(nSsrData))
-      setStatus("loaded")
-      setError(undefined)
+      setSsrData(parseData(nSsrData))
     } else {
       if (!url) {
         setError(`No url provided for ${name}`)
       } else {
         const resp = await fetcher.get(url, params)
         if (resp.ok) {
-          setSsrData(_parseData(resp?.data))
-          setStatus("loaded")
-          setError(undefined)
+          setSsrData(parseData(resp?.data))
         } else {
           setError(resp?.error || "Unknonwn error")
-          setStatus("loaded")
         }
       }
     }
-  }, [context, fetcher, loader, url, params, _parseData, name])
+    setStatus("loaded")
+  }, [status, context, fetcher, loader, url, params, parseData, name])
+
+  useEffect(() => {
+    if (prevLoader.current !== undefined && prevLoader.current !== loader) {
+      const now = Date.now()
+      // Si el cambio ocurrió rápido (<100ms desde el último cambio), sumamos al contador continuo
+      if (now - loaderChangeTime.current < 100) {
+        loaderChangeCount.current += 1
+        if (loaderChangeCount.current >= 4) {
+          console.warn(
+            "🚨 [miolo][useSsrDataOrReload]: 'options.loader' varies too frequently. Wrap it in a useCallback!"
+          )
+        }
+      } else {
+        // Ha pasado suficiente tiempo como para ser un cambio humano/aislado
+        loaderChangeCount.current = 1
+      }
+      loaderChangeTime.current = now
+    }
+    prevLoader.current = loader
+  }) // Evalúa en cada render
+
+  useEffect(() => {
+    if (prevEffect.current !== undefined && prevEffect.current !== effect) {
+      const now = Date.now()
+      if (now - effectChangeTime.current < 100) {
+        effectChangeCount.current += 1
+        if (effectChangeCount.current >= 4) {
+          console.warn(
+            "🚨 [miolo][useSsrDataOrReload]: 'options.effect' varies too frequently. Wrap it in a useMemo or useCallback!"
+          )
+        }
+      } else {
+        effectChangeCount.current = 1
+      }
+      effectChangeTime.current = now
+    }
+    prevEffect.current = effect
+  }) // Evalúa en cada render
 
   useEffect(() => {
     try {
-      if (needToRefresh) {
-        const changed = effect === undefined || effect.check()
-        if (changed) {
-          setNeedToRefresh(false)
+      if (status === "idle") {
+        const changed = effect?.() === true
+        if (changed === true) {
           refreshSsrData()
         }
       }
     } catch (_) {}
-  }, [needToRefresh, refreshSsrData, effect, ...(effect?.deps || [])])
+  }, [status, refreshSsrData, effect])
 
   return {
     data: ssrData,
-    setData: (data) => setSsrData(_parseData(data)),
+    setData: updateSsrData,
     refresh: refreshSsrData,
     error,
     ok: error === undefined,
-    ready: status === "loaded" || status === "error"
+    ready: status === "loaded"
   }
 }