one 1.15.8 → 1.15.9

package/dist/cjs/useLoader.cjs

@@ -52,28 +52,24 @@ const loaderTimingHistory = [];
 const MAX_TIMING_HISTORY = 50;
 const recordLoaderTiming = process.env.NODE_ENV === "development" ? entry => {
   loaderTimingHistory.unshift(entry);
-  if (loaderTimingHistory.length > MAX_TIMING_HISTORY) {
-    loaderTimingHistory.pop();
-  }
+  if (loaderTimingHistory.length > MAX_TIMING_HISTORY) loaderTimingHistory.pop();
   if (typeof window !== "undefined" && typeof CustomEvent !== "undefined") {
     window.dispatchEvent(new CustomEvent("one-loader-timing", {
       detail: entry
     }));
-    if (entry.error) {
-      window.dispatchEvent(new CustomEvent("one-error", {
-        detail: {
-          error: {
-            message: entry.error,
-            name: "LoaderError"
-          },
-          route: {
-            pathname: entry.path
-          },
-          timestamp: Date.now(),
-          type: "loader"
-        }
-      }));
-    }
+    if (entry.error) window.dispatchEvent(new CustomEvent("one-error", {
+      detail: {
+        error: {
+          message: entry.error,
+          name: "LoaderError"
+        },
+        route: {
+          pathname: entry.path
+        },
+        timestamp: Date.now(),
+        type: "loader"
+      }
+    }));
   }
 } : void 0;
 function getLoaderTimingHistory() {
@@ -97,15 +93,13 @@ function subscribe(callback) {
   return () => subscribers.delete(callback);
 }
 function getLoaderState(path, preloadedData2) {
-  if (!loaderState[path]) {
-    loaderState[path] = {
-      data: preloadedData2,
-      error: void 0,
-      promise: void 0,
-      state: "idle",
-      hasLoadedOnce: !!preloadedData2
-    };
-  }
+  if (!loaderState[path]) loaderState[path] = {
+    data: preloadedData2,
+    error: void 0,
+    promise: void 0,
+    state: "idle",
+    hasLoadedOnce: !!preloadedData2
+  };
   return loaderState[path];
 }
 async function refetchLoader(pathname2) {
@@ -176,9 +170,7 @@ async function refetchLoader(pathname2) {
     const pageMatch = currentMatches[currentMatches.length - 1];
     const normalizedPathname = pathname2.replace(/\/$/, "") || "/";
     const normalizedMatchPathname = (pageMatch?.pathname || "").replace(/\/$/, "") || "/";
-    if (pageMatch && normalizedMatchPathname === normalizedPathname) {
-      (0, import_useMatches.updateMatchLoaderData)(pageMatch.routeId, result2);
-    }
+    if (pageMatch && normalizedMatchPathname === normalizedPathname) (0, import_useMatches.updateMatchLoaderData)(pageMatch.routeId, result2);
     recordLoaderTiming?.({
       path: pathname2,
       startTime: startTime2,
@@ -203,10 +195,7 @@ async function refetchLoader(pathname2) {
     throw err;
   }
 }
-if (process.env.NODE_ENV === "development" && typeof window !== "undefined") {
-  ;
-  window.__oneRefetchLoader = refetchLoader;
-}
+if (process.env.NODE_ENV === "development" && typeof window !== "undefined") window.__oneRefetchLoader = refetchLoader;
 async function refetchMatchLoader(routeId, currentPath2) {
   const cacheBust = `${Date.now()}`;
   const loaderJSUrl2 = (0, import_cleanUrl.getLoaderPath)(currentPath2, true, cacheBust);
@@ -226,42 +215,35 @@ function useLoaderState(loader) {
   const currentPath = pathname.replace(/\/index$/, "").replace(/\/$/, "") || "/";
   if (typeof window === "undefined") {
     if (loader) {
-      if (import_ssrLoaderData.ssrLoaderData.has(loader)) {
-        return {
-          data: import_ssrLoaderData.ssrLoaderData.get(loader),
-          refetch: async () => {},
-          state: "idle"
-        };
-      }
+      if (import_ssrLoaderData.ssrLoaderData.has(loader)) return {
+        data: import_ssrLoaderData.ssrLoaderData.get(loader),
+        refetch: async () => {},
+        state: "idle"
+      };
       const serverContext = (0, import_one_server_only.useServerContext)();
       if (serverContext?.matches) {
         const contextKey = (0, import_Route.useContextKey)();
         const match = serverContext.matches.find(m => (0, import_matchers.getContextKey)(m.routeId) === contextKey);
-        if (match && match.loaderData !== void 0) {
-          return {
-            data: match.loaderData,
-            refetch: async () => {},
-            state: "idle"
-          };
-        }
+        if (match && match.loaderData !== void 0) return {
+          data: match.loaderData,
+          refetch: async () => {},
+          state: "idle"
+        };
       }
-      const serverData = useAsyncFn(loader, loaderPropsFromServerContext || {
-        path: pathname,
-        params
-      });
-      return {
-        data: serverData,
-        refetch: async () => {},
-        state: "idle"
-      };
-    }
-    if (loaderDataFromServerContext !== void 0) {
       return {
-        data: loaderDataFromServerContext,
+        data: useAsyncFn(loader, loaderPropsFromServerContext || {
+          path: pathname,
+          params
+        }),
         refetch: async () => {},
         state: "idle"
       };
     }
+    if (loaderDataFromServerContext !== void 0) return {
+      data: loaderDataFromServerContext,
+      refetch: async () => {},
+      state: "idle"
+    };
   }
   const matchRouteId = loader ? (() => {
     const result2 = loader();
@@ -277,28 +259,20 @@ function useLoaderState(loader) {
     const isPageMatch = clientMatches.length > 0 && clientMatches[clientMatches.length - 1]?.routeId === matchRouteId;
     const matchPathNormalized = (match?.pathname || "").replace(/\/$/, "") || "/";
     const matchPathFresh = !isPageMatch || matchPathNormalized === currentPath;
-    if (match && match.loaderData != null && matchPathFresh) {
-      return {
-        data: match.loaderData,
-        // refetch updates both loaderState (for useLoaderState() consumers without a loader)
-        // and the match entry (for this component and useMatches consumers)
-        refetch: async () => {
-          await refetchLoader(currentPath);
-          const fresh = loaderState[currentPath];
-          if (fresh?.data != null) {
-            (0, import_useMatches.updateMatchLoaderData)(matchRouteId, fresh.data);
-          }
-        },
-        state: loaderStateEntry.state
-      };
-    }
-  }
-  if (!loader) {
-    return {
-      refetch,
+    if (match && match.loaderData != null && matchPathFresh) return {
+      data: match.loaderData,
+      refetch: async () => {
+        await refetchLoader(currentPath);
+        const fresh = loaderState[currentPath];
+        if (fresh?.data != null) (0, import_useMatches.updateMatchLoaderData)(matchRouteId, fresh.data);
+      },
       state: loaderStateEntry.state
     };
   }
+  if (!loader) return {
+    refetch,
+    state: loaderStateEntry.state
+  };
   if (!loaderStateEntry.data && !loaderStateEntry.promise && !loaderStateEntry.hasLoadedOnce) {
     const resolvedPreloadData = import_router.preloadedLoaderData[currentPath];
     if (resolvedPreloadData != null) {
@@ -306,137 +280,27 @@ function useLoaderState(loader) {
       delete import_router.preloadingLoader[currentPath];
       loaderStateEntry.data = resolvedPreloadData;
       loaderStateEntry.hasLoadedOnce = true;
-    } else if (import_router.preloadingLoader[currentPath]) {
-      const preloadPromise = import_router.preloadingLoader[currentPath];
-      const promise2 = preloadPromise.then(val => {
-        delete import_router.preloadingLoader[currentPath];
-        delete import_router.preloadedLoaderData[currentPath];
-        if (val != null) {
-          updateState(currentPath, {
-            data: val,
-            hasLoadedOnce: true,
-            promise: void 0
-          });
-        } else {
-          updateState(currentPath, {
-            promise: void 0
-          });
-        }
-      }).catch(err => {
-        console.error(`Error running loader()`, err);
-        delete import_router.preloadingLoader[currentPath];
-        updateState(currentPath, {
-          error: err,
-          promise: void 0
-        });
+    } else if (import_router.preloadingLoader[currentPath]) loaderStateEntry.promise = import_router.preloadingLoader[currentPath].then(val => {
+      delete import_router.preloadingLoader[currentPath];
+      delete import_router.preloadedLoaderData[currentPath];
+      if (val != null) updateState(currentPath, {
+        data: val,
+        hasLoadedOnce: true,
+        promise: void 0
+      });else updateState(currentPath, {
+        promise: void 0
+      });
+    }).catch(err => {
+      console.error(`Error running loader()`, err);
+      delete import_router.preloadingLoader[currentPath];
+      updateState(currentPath, {
+        error: err,
+        promise: void 0
       });
-      loaderStateEntry.promise = promise2;
-    } else {
+    });else {
       const loadData = async () => {
         const startTime = performance.now();
         try {
-          if (false) {
-            let nativeLoaderJSUrl;
-            if (process.env.NODE_ENV === "development") {
-              nativeLoaderJSUrl = `${(0, import_cleanUrl.getLoaderPath)(currentPath, true)}?platform=native`;
-            } else {
-              const {
-                getURL
-              } = null;
-              const base = getURL();
-              const cleanedPath = currentPath.slice(1).replace(/\/$/, "").replaceAll("_", "__").replaceAll("/", "_");
-              nativeLoaderJSUrl = `${base}/assets/${cleanedPath}${LOADER_JS_POSTFIX_UNCACHED.replace(".js", ".native.js")}`;
-            }
-            try {
-              const moduleLoadStart = performance.now();
-              const controller = new AbortController();
-              const timeoutId = setTimeout(() => controller.abort(), LOADER_TIMEOUT);
-              let loaderJsCode;
-              try {
-                const loaderJsCodeResp = await fetch(nativeLoaderJSUrl, {
-                  signal: controller.signal
-                });
-                if (!loaderJsCodeResp.ok) {
-                  throw new Error(`Response not ok: ${loaderJsCodeResp.status}`);
-                }
-                loaderJsCode = await loaderJsCodeResp.text();
-              } finally {
-                clearTimeout(timeoutId);
-              }
-              const result = eval(`() => { var exports = {}; ${loaderJsCode}; return exports; }`)();
-              const moduleLoadTime = performance.now() - moduleLoadStart;
-              if (typeof result.loader !== "function") {
-                throw new Error("Loader code isn't exporting a `loader` function");
-              }
-              const executionStart = performance.now();
-              const data = await result.loader();
-              const executionTime = performance.now() - executionStart;
-              const totalTime = performance.now() - startTime;
-              if (data?.__oneRedirect) {
-                recordLoaderTiming?.({
-                  path: currentPath,
-                  startTime,
-                  moduleLoadTime,
-                  executionTime,
-                  totalTime,
-                  source: "initial"
-                });
-                updateState(currentPath, {
-                  data: void 0,
-                  hasLoadedOnce: true,
-                  promise: void 0
-                });
-                import_imperative_api.router.replace(data.__oneRedirect);
-                return;
-              }
-              if (data?.__oneError === 404) {
-                recordLoaderTiming?.({
-                  path: currentPath,
-                  startTime,
-                  moduleLoadTime,
-                  executionTime,
-                  totalTime,
-                  source: "initial"
-                });
-                const notFoundRoute = (0, import_notFoundState.findNearestNotFoundRoute)(currentPath, import_router.routeNode);
-                (0, import_notFoundState.setNotFoundState)({
-                  notFoundPath: data.__oneNotFoundPath || "/+not-found",
-                  notFoundRouteNode: notFoundRoute || void 0,
-                  originalPath: currentPath
-                });
-                return;
-              }
-              updateState(currentPath, {
-                data,
-                hasLoadedOnce: true,
-                promise: void 0
-              });
-              recordLoaderTiming?.({
-                path: currentPath,
-                startTime,
-                moduleLoadTime,
-                executionTime,
-                totalTime,
-                source: "initial"
-              });
-              return;
-            } catch (e) {
-              console.error(`[one] native loader error for ${currentPath}:`, e instanceof Error ? e.message : e, `url: ${nativeLoaderJSUrl}`);
-              const totalTime2 = performance.now() - startTime;
-              updateState(currentPath, {
-                data: {},
-                promise: void 0
-              });
-              recordLoaderTiming?.({
-                path: currentPath,
-                startTime,
-                totalTime: totalTime2,
-                error: e instanceof Error ? e.message : String(e),
-                source: "initial"
-              });
-              return;
-            }
-          }
           const loaderJSUrl = (0, import_cleanUrl.getLoaderPath)(currentPath, true);
           const moduleLoadStart = performance.now();
           const module = await (0, import_dynamicImport.dynamicImport)(loaderJSUrl)?.catch(() => null);
@@ -519,12 +383,8 @@ function useLoaderState(loader) {
       loaderStateEntry.promise = promise;
     }
   }
-  if (loaderStateEntry.error && !loaderStateEntry.hasLoadedOnce) {
-    throw loaderStateEntry.error;
-  }
-  if (loaderStateEntry.data === void 0 && loaderStateEntry.promise && !loaderStateEntry.hasLoadedOnce) {
-    throw loaderStateEntry.promise;
-  }
+  if (loaderStateEntry.error && !loaderStateEntry.hasLoadedOnce) throw loaderStateEntry.error;
+  if (loaderStateEntry.data === void 0 && loaderStateEntry.promise && !loaderStateEntry.hasLoadedOnce) throw loaderStateEntry.promise;
   return {
     data: loaderStateEntry.data,
     refetch,
@@ -549,20 +409,16 @@ function useAsyncFn(val, props) {
     if (!started.get(key)) {
       started.set(key, true);
       let next = val(props);
-      if (next instanceof Promise) {
-        next = next.then(final => {
-          results.set(key, final);
-        }).catch(err => {
-          console.error(`Error running loader()`, err);
-          results.set(key, void 0);
-        });
-      }
+      if (next instanceof Promise) next = next.then(final => {
+        results.set(key, final);
+      }).catch(err => {
+        console.error(`Error running loader()`, err);
+        results.set(key, void 0);
+      });
       results.set(key, next);
     }
   }
   const current = results.get(key);
-  if (current instanceof Promise) {
-    throw current;
-  }
+  if (current instanceof Promise) throw current;
   return current;
 }