async-fetch 0.2.8 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # useAsyncFetch
 
-Use fetch asynchronously for requests within React components.
+Use fetch for requests within React components.
 
 ## Installation
 
@@ -18,7 +18,7 @@ import useAsyncFetch from "async-fetch";
 
 function App() {
   const { pending, data, error, sendRequest, cancelRequest } = useAsyncFetch(
-    "https://jsonplaceholder.typicode.com/todos/1"
+    "https://jsonplaceholder.typicode.com/todos/1",
   );
 
   return (

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "async-fetch",
-  "version": "0.2.8",
-  "description": "Use fetch asynchronously for requests within React components.",
+  "version": "0.3.0",
+  "description": "Use fetch for requests within React components.",
   "main": "useAsyncFetch.js",
   "type": "module",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
+  "scripts": {},
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nameer-rizvi/useAsyncFetch.git"
@@ -19,8 +17,6 @@
   ],
   "author": "Nameer Rizvi (https://github.com/nameer-rizvi)",
   "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/nameer-rizvi/useAsyncFetch/issues"
-  },
+  "bugs": "https://github.com/nameer-rizvi/useAsyncFetch/issues",
   "homepage": "https://github.com/nameer-rizvi/useAsyncFetch#readme"
 }

package/useAsyncFetch.js

@@ -2,7 +2,7 @@ import { useState, useEffect } from "react";
 import useCache from "./useCache.js";
 import useInterval from "./useInterval.js";
 
-function useAsyncFetch(path, props = {}) {
+function useAsyncFetch(requestURL, props = {}) {
   const {
     initialPending,
     initialData,
@@ -10,7 +10,7 @@ function useAsyncFetch(path, props = {}) {
     deps = [],
     poll,
     cachetime = 60000, // 1 minute.
-    timeout = 30000, // 5 minutes.
+    timeout = 30000, // 30 seconds.
     ignoreCleanup,
     ignoreRequest,
     query,
@@ -62,10 +62,15 @@ function useAsyncFetch(path, props = {}) {
   }
 
   async function sendRequest(constant) {
-    if (!path) throw new Error("URL is required.");
+    if (!requestURL) {
+      throw new Error("URL is required.");
+    }
 
-    if (typeof path !== "string")
+    if (typeof requestURL !== "string") {
       throw new Error("URL must be of type string.");
+    }
+
+    const url = new URL(requestURL);
 
     if (ignoreRequest !== true) {
       const controller = new AbortController();
@@ -77,51 +82,43 @@ function useAsyncFetch(path, props = {}) {
       }, timeout);
 
       try {
-        let q = "";
-
-        if (query || params) {
-          if (!path.endsWith("?")) q += "?";
-          q += new URLSearchParams(query || params).toString();
-        }
+        if (query || params) url.search = new URLSearchParams(query || params);
 
         const contentType =
           fetchProps.headers?.["Content-Type"] ||
           fetchProps.headers?.["content-type"];
 
         if (contentType === "application/x-www-form-urlencoded") {
-          fetchProps.body = new URLSearchParams(data2 || {}).toString();
+          fetchProps.body = new URLSearchParams(data2 || {});
         } else if (data2) {
           fetchProps.body = JSON.stringify(data2);
         }
 
         if (!unmounted) {
-          if (pending) {
-            setPending2(true);
-          } else setPending(true);
+          if (pending) setPending2(true);
+          if (!pending) setPending(true);
           setError();
           cancelRequest();
           setCancelSource(controller);
           if (onStart) onStart();
         }
 
-        const url = path + q;
-
-        const cachedResponse =
-          constant === "USE_CACHE" && cache.get(url, fetchProps);
+        const cachedResponse = constant === "USE_CACHE" && cache.get(url.href);
 
         let parsedResponse = cachedResponse;
 
         if (!parsedResponse) {
           const response = await fetch(url, fetchProps);
 
-          if (!response.ok)
+          if (!response.ok) {
             throw new Error(
               JSON.stringify({
                 code: response.status,
                 text: response.statusText,
                 response: await response.text(),
-              })
+              }),
             );
+          }
 
           parsedResponse = await response[parser]();
         }
@@ -129,7 +126,7 @@ function useAsyncFetch(path, props = {}) {
         if (!unmounted) {
           setData(parsedResponse);
           if (onSuccess) onSuccess(parsedResponse);
-          if (!cachedResponse) cache.set(url, fetchProps, parsedResponse);
+          if (!cachedResponse) cache.set(url, parsedResponse);
         }
       } catch (e) {
         if (!unmounted && e.name !== "AbortError") {

package/useCache.js

@@ -4,27 +4,17 @@ const cache = {};
 
 function useCache(cachetime) {
   useInterval(() => {
-    for (let [key, value] of Object.entries(cache))
+    for (let [key, value] of Object.entries(cache)) {
       if (value.timestamp + cachetime < new Date().getTime()) delete cache[key];
+    }
   }, cachetime);
 
-  function makeKey(url, fetchProps) {
-    return typeof fetchProps.body === "string" ? url + fetchProps.body : url;
+  function get(url) {
+    if (cachetime) return cache[url]?.response;
   }
 
-  function get(url, fetchProps) {
-    if (cachetime) {
-      const key = makeKey(url, fetchProps);
-      return cache[key]?.response;
-    }
-  }
-
-  function set(url, fetchProps, response) {
-    if (cachetime) {
-      const key = makeKey(url, fetchProps);
-      const payload = { timestamp: new Date().getTime(), response };
-      cache[key] = payload;
-    }
+  function set(url, response) {
+    if (cachetime) cache[url] = { timestamp: new Date().getTime(), response };
   }
 
   return { get, set };

package/useInterval.js

@@ -8,9 +8,8 @@ function useInterval(callback, poll) {
   });
 
   useEffect(() => {
-    if (!poll) return;
-    const onTick = () => callbackRef.current();
-    const interval = setInterval(onTick, poll);
+    if (typeof poll !== "number") return;
+    const interval = setInterval(() => callbackRef.current(), poll);
     return () => {
       clearInterval(interval);
     };