@krainovsd/js-helpers 0.19.0-beta.1 → 0.19.0-beta.2

package/lib/cjs/index.cjs

@@ -1757,13 +1757,14 @@ function throttle(func, interval) {
 
 const RESPONSE_DATA_SYMBOL = Symbol("response data");
 const REQUEST_ERROR = {
-    HTTP_ERROR: "http",
-    NETWORK_ERROR: "network",
-    TIMEOUT_ERROR: "timeout",
-    ABORT_ERROR: "abort",
-    VALIDATION_ERROR: "validation",
-    CACHE_ERROR: "cache",
-    UNKNOWN_ERROR: "unknown",
+    Http: "http",
+    Network: "network",
+    Timeout: "timeout",
+    Abort: "abort",
+    Validation: "validation",
+    Cache: "cache",
+    Unknown: "unknown",
+    Disabled: "disabled",
 };
 class OauthState {
     _fetching = false;
@@ -1789,6 +1790,7 @@ function createFetchClient(options) {
     let retries = options.retries;
     let timeout = options.timeout;
     let refetchAfterAuthGlobal = options.refetchAfterAuth;
+    let enabled = options.enabled ?? true;
     function recreate(options) {
         if ("client" in options) {
             client = options.client;
@@ -1808,8 +1810,18 @@ function createFetchClient(options) {
         if ("refetchAfterAuth" in options) {
             refetchAfterAuthGlobal = options.refetchAfterAuth;
         }
+        if ("enabled" in options) {
+            enabled = options.enabled ?? true;
+        }
     }
     async function handleRequest(request) {
+        if (!enabled) {
+            return {
+                response: null,
+                data: new ResponseError({ message: "requests disabled", status: 0 }),
+                error: REQUEST_ERROR.Disabled,
+            };
+        }
         const timeoutController = new AbortController();
         const requestController = new AbortController();
         const requestTimeout = request.timeout ?? timeout;
@@ -1918,12 +1930,12 @@ function createFetchClient(options) {
             if (!response.ok) {
                 if (response.status === 304) {
                     const error = new ResponseError({
-                        message: REQUEST_ERROR.CACHE_ERROR,
+                        message: REQUEST_ERROR.Cache,
                         status: response.status,
                         headers: Object.fromEntries(response.headers.entries()),
                     });
-                    request.onError?.(REQUEST_ERROR.CACHE_ERROR, error);
-                    return { data: error, error: REQUEST_ERROR.CACHE_ERROR, response };
+                    request.onError?.(REQUEST_ERROR.Cache, error);
+                    return { data: error, error: REQUEST_ERROR.Cache, response };
                 }
                 /** if you need observe other than only 401 status, you can override some statuses in after handler middleware to 401 */
                 if (response.status === 401 && refetchAfterAuth) {
@@ -1966,14 +1978,14 @@ function createFetchClient(options) {
                 catch { }
                 const error = new ResponseError({
                     status: response.status,
-                    message: REQUEST_ERROR.HTTP_ERROR,
+                    message: REQUEST_ERROR.Http,
                     description: result,
                     headers: Object.fromEntries(response.headers.entries()),
                 });
-                request.onError?.(REQUEST_ERROR.HTTP_ERROR, error);
+                request.onError?.(REQUEST_ERROR.Http, error);
                 return {
                     data: error,
-                    error: REQUEST_ERROR.HTTP_ERROR,
+                    error: REQUEST_ERROR.Http,
                     response,
                 };
             }
@@ -2042,36 +2054,36 @@ function createFetchClient(options) {
             }
             if (err instanceof TypeError) {
                 const error = new ResponseError({
-                    message: REQUEST_ERROR.NETWORK_ERROR,
+                    message: REQUEST_ERROR.Network,
                     status: 0,
                     description: String(err.message),
                 });
-                request.onError?.(REQUEST_ERROR.NETWORK_ERROR, error);
-                return { data: error, error: REQUEST_ERROR.NETWORK_ERROR, response: null };
+                request.onError?.(REQUEST_ERROR.Network, error);
+                return { data: error, error: REQUEST_ERROR.Network, response: null };
             }
             if (err instanceof Error && err.name === "AbortError") {
                 if (timeoutController.signal.aborted) {
                     const error = new ResponseError({
-                        message: REQUEST_ERROR.TIMEOUT_ERROR,
+                        message: REQUEST_ERROR.Timeout,
                         status: 0,
                     });
-                    request.onError?.(REQUEST_ERROR.TIMEOUT_ERROR, error);
-                    return { data: error, error: REQUEST_ERROR.TIMEOUT_ERROR, response: null };
+                    request.onError?.(REQUEST_ERROR.Timeout, error);
+                    return { data: error, error: REQUEST_ERROR.Timeout, response: null };
                 }
                 const error = new ResponseError({
-                    message: REQUEST_ERROR.ABORT_ERROR,
+                    message: REQUEST_ERROR.Abort,
                     status: 0,
                 });
-                request.onError?.(REQUEST_ERROR.ABORT_ERROR, error);
-                return { data: error, error: REQUEST_ERROR.ABORT_ERROR, response: null };
+                request.onError?.(REQUEST_ERROR.Abort, error);
+                return { data: error, error: REQUEST_ERROR.Abort, response: null };
             }
             const error = new ResponseError({
-                message: REQUEST_ERROR.UNKNOWN_ERROR,
+                message: REQUEST_ERROR.Unknown,
                 status: 0,
                 description: String(err),
             });
-            request.onError?.(REQUEST_ERROR.UNKNOWN_ERROR, error);
-            return { data: error, error: REQUEST_ERROR.UNKNOWN_ERROR, response: null };
+            request.onError?.(REQUEST_ERROR.Unknown, error);
+            return { data: error, error: REQUEST_ERROR.Unknown, response: null };
         }
         finally {
             requestController.abort();
@@ -2261,6 +2273,9 @@ function createOauthProvider(opts = {}) {
         register,
         refetchAfterRefreshFlow,
         beforeHandler,
+        get isServicePage() {
+            return [errorPageUrl, clearPageUrl, logoutPageUrl].some((u) => document.location.pathname === u);
+        },
         get processing() {
             return processing;
         },