@krainovsd/js-helpers 0.15.2 → 0.16.0

package/lib/cjs/index.cjs

@@ -9,22 +9,19 @@ const yesterdayPlugin = require('dayjs/plugin/isYesterday');
 const get = require('lodash/get');
 const set = require('lodash/set');
 
-const DATE_TYPES = {
-    Days: "days",
-    Months: "months",
-    Years: "years",
-    Seconds: "seconds",
-    Minutes: "minutes",
-    Hours: "hours",
-};
-
-const API_MIDDLEWARES = {
-    Oauth: "oauth",
-    Logger: "logger",
-};
-const POST_API_MIDDLEWARES = {
-    Logger: "logger",
-};
+class ResponseError extends Error {
+    status;
+    code;
+    description;
+    headers;
+    constructor({ message, status, description, code, headers }) {
+        super(message);
+        this.status = status;
+        this.description = description;
+        this.code = code;
+        this.headers = headers;
+    }
+}
 
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/ban-ts-comment */
@@ -49,7 +46,14 @@ const COLOR_FORMATS = {
     Rgba: "RGBA",
     Hsl: "HSL",
 };
-
+const DATE_TYPES = {
+    Days: "days",
+    Months: "months",
+    Years: "years",
+    Seconds: "seconds",
+    Minutes: "minutes",
+    Hours: "hours",
+};
 const FIELD_TYPES = {
     Date: "date",
     Time: "time",
@@ -320,7 +324,7 @@ function buildQueryString(params) {
     return queryString.join("&");
 }
 
-function createURLWithParams(options) {
+function createURLWithQueries(options) {
     const url = options.baseURL;
     if (!options.params) {
         return url;
@@ -1308,554 +1312,81 @@ function extractQueries() {
     return queryMap;
 }
 
-const RESPONSE_DATA_SYMBOL = Symbol("response data");
-
-function generateConsoleMiddleware(options = {}) {
-    return (request) => {
-        return new Promise((resolve) => {
-            if ((options.filter &&
-                !options.filter(request)) ||
-                (options.filterHeaders && !options.filterHeaders(request.headers)) ||
-                (options.filterMethod && !options.filterMethod(request.method)) ||
-                (options.filterParams && !options.filterParams(request.params)) ||
-                (options.filterPath && !options.filterPath(request.path))) {
-                resolve(true);
-                return;
-            }
-            // eslint-disable-next-line no-console
-            console.log(request);
-            resolve(true);
-        });
-    };
+function getColorFormat(color) {
+    if (color.startsWith("#")) {
+        return COLOR_FORMATS.Hex;
+    }
+    if (color.startsWith("rgba")) {
+        return COLOR_FORMATS.Rgba;
+    }
+    if (color.startsWith("rgb")) {
+        return COLOR_FORMATS.Rgb;
+    }
+    if (color.startsWith("hsl")) {
+        return COLOR_FORMATS.Hsl;
+    }
 }
 
-function generateConsolePostMiddleware(options = {}) {
-    return (response) => {
-        return new Promise((resolve) => {
-            void (async function logger() {
-                try {
-                    if (!response ||
-                        (options.filter && !options.filter(response)) ||
-                        (options.filterStatus && !options.filterStatus(response.status)) ||
-                        (options.filterUrl && !options.filterUrl(response.url)) ||
-                        (options.filterHeaders && !options.filterHeaders(response.headers))) {
-                        resolve(true);
-                        return;
-                    }
-                    const contentType = response.headers.get("content-type");
-                    let result;
-                    if (contentType?.includes?.("text")) {
-                        result = await response.text();
-                    }
-                    else if (contentType?.includes?.("json")) {
-                        result = await response.json();
-                    }
-                    else {
-                        result = await response.blob();
-                    }
-                    Object.defineProperty(response, RESPONSE_DATA_SYMBOL, {
-                        value: result,
-                        writable: false,
-                        enumerable: false,
-                        configurable: true,
-                    });
-                    console.log({
-                        url: response.url,
-                        status: response.status,
-                        headers: response.headers,
-                        body: result,
-                    });
-                    resolve(true);
-                }
-                catch {
-                    if (response) {
-                        console.log({ url: response.url, status: response.status, headers: response.headers });
-                    }
-                    resolve(true);
-                }
-            })().finally(() => {
-                resolve(true);
-            });
-        });
-    };
+function transformHEXtoRGB(hex) {
+    return `rgb(${hex.match(/\w\w/g)?.map((x) => +`0x${x}`)})`;
 }
 
-let waiting = false;
-async function getOauthTokenFromOtherWindow(options) {
-    await waitUntil(() => waiting);
-    const expires = localStorage.getItem(options.expiresTokenStorageName);
-    if (expires != undefined && !Number.isNaN(+expires) && Date.now() < +expires)
-        return;
-    waiting = true;
-    const url = new URL(typeof options.refreshTokenWindowUrl === "function"
-        ? options.refreshTokenWindowUrl()
-        : (options.refreshTokenWindowUrl ?? window.origin));
-    url.searchParams.append(options.onlyRefreshTokenWindowQueryName, "true");
-    let windowInstance = window.open(url.toString(), "_blank", "width=800,height=600,left=100,top=100");
-    windowInstance ??= window.open(url.toString(), "_blank");
-    if (windowInstance) {
-        const channel = new BroadcastChannel(options.onlyRefreshTokenWindowQueryName);
-        const windowCloseObserver = setInterval(() => {
-            if (windowInstance.closed) {
-                if (waiting) {
-                    waiting = false;
-                    channel.close();
-                    clearInterval(windowCloseObserver);
-                }
-            }
-        }, options.closeObserveInterval ?? 500);
-        channel.onmessage = () => {
-            if (waiting) {
-                waiting = false;
-                channel.close();
-                clearInterval(windowCloseObserver);
-            }
-        };
-        setTimeout(() => {
-            if (waiting) {
-                waiting = false;
-                channel.close();
-                clearInterval(windowCloseObserver);
-            }
-            if (windowInstance && !windowInstance.closed) {
-                windowInstance.close();
-            }
-        }, options.wait ?? 15000);
-    }
-    else {
-        if (options.onWindowOpenError)
-            options.onWindowOpenError();
-        waiting = false;
-        return;
-    }
-    await waitUntil(() => waiting);
+function transformRGBtoRGBA(rgb, opacity) {
+    const code = rgb.match(/\d+/g);
+    code?.push(String(opacity / 100));
+    return `rgba(${code?.join(",")})`;
 }
-function getOauthToken(options) {
-    let expires = localStorage.getItem(options.expiresTokenStorageName);
-    if (!expires || Number.isNaN(+expires) || Date.now() > +expires)
-        expires = null;
-    const queries = getQueryValues([
-        options.expiresTokenQueryName,
-        options.onlyRefreshTokenWindowQueryName,
-    ]);
-    const refreshQuery = queries?.[options.onlyRefreshTokenWindowQueryName];
-    const expiresQuery = queries?.[options.expiresTokenQueryName];
-    /** Is OnlyRefresh window */
-    const isRefresh = isString(refreshQuery)
-        ? refreshQuery === "true"
-        : isArray(refreshQuery)
-            ? refreshQuery[refreshQuery.length - 1] === "true"
-            : false;
-    /** Expires token */
-    const expiresFromQuery = isString(expiresQuery)
-        ? expiresQuery
-        : isArray(expiresQuery)
-            ? expiresQuery[expiresQuery.length - 1]
-            : false;
-    /** Extract expires from query */
-    if (!expires && expiresFromQuery) {
-        expires = expiresFromQuery;
-        if (!expires || Number.isNaN(+expires) || Date.now() > +expires)
-            expires = null;
-    }
-    /** OAuth flow if not expires */
-    if (!expires) {
-        window.location.replace(typeof options.oauthUrl === "function" ? options.oauthUrl() : options.oauthUrl);
-        return null;
-    }
-    localStorage.setItem(options.expiresTokenStorageName, expires);
-    /** Close if OnlyRefresh window  */
-    if (isRefresh) {
-        const channel = new BroadcastChannel(options.onlyRefreshTokenWindowQueryName);
-        channel.postMessage(true);
-        channel.close();
-        window.close();
-    }
-    /** Delete expires query */
-    if (expiresFromQuery) {
-        const url = new URL(window.location.href);
-        url.searchParams.delete(options.expiresTokenQueryName);
-        window.location.replace(url.toString());
-        return null;
-    }
-    return expires;
+
+function transformRGBAtoRGB(rgba) {
+    const code = rgba.match(/\d+/g);
+    code?.splice(3);
+    return `rgb(${code?.join(",")})`;
 }
 
-async function updateAuthUser(options) {
-    const userInfo = await (options.userRequest ? options.userRequest() : getAuthUser(options));
-    if (isNull(userInfo)) {
-        return void window.location.replace(options.oauthUrl());
+function takeOpacityColors(color, opacities) {
+    let rgbColor = color;
+    if (!rgbColor)
+        return [];
+    if (getColorFormat(rgbColor) === COLOR_FORMATS.Hex) {
+        rgbColor = transformHEXtoRGB(rgbColor);
     }
-    if (isUndefined(userInfo)) {
-        return void window.location.replace(options.errorUrl);
+    else if (getColorFormat(rgbColor) === COLOR_FORMATS.Rgba) {
+        rgbColor = transformRGBAtoRGB(rgbColor);
     }
-    return userInfo;
+    if (getColorFormat(rgbColor) !== COLOR_FORMATS.Rgb)
+        return [];
+    return [...opacities.map((opacity) => transformRGBtoRGBA(rgbColor, opacity))];
 }
-async function getAuthUser(options) {
-    let status = 0;
-    try {
-        const response = await fetch(options.authUserUrl, {
-            method: "GET",
-        });
-        status = response.status;
-        if (!response.ok) {
-            throw new Error(`HTTP error! Status: ${response.status}`);
+
+function transformToColor(currentColor, defaultColor = "black", defaultFormat = COLOR_FORMATS.Hex) {
+    if (!isString(currentColor))
+        return defaultColor;
+    let correctColor = currentColor;
+    if (!getColorFormat(correctColor)) {
+        switch (defaultFormat) {
+            case COLOR_FORMATS.Hex: {
+                correctColor = `#${correctColor}`;
+                break;
+            }
+            case COLOR_FORMATS.Rgb: {
+                correctColor = `rgb(${correctColor})`;
+                break;
+            }
+            case COLOR_FORMATS.Rgba: {
+                correctColor = `rgba(${correctColor})`;
+                break;
+            }
+            case COLOR_FORMATS.Hsl: {
+                correctColor = `hsl(${correctColor})`;
+                break;
+            }
+            default: {
+                correctColor = `#${correctColor}`;
+                break;
+            }
         }
-        const result = (await response.json());
-        return result;
-    }
-    catch {
-        if (status >= 500)
-            return undefined;
-        return null;
     }
-}
-
-let isFetchingAccessToken = false;
-const generateOauthMiddleware = (options) => async (request) => {
-    if (!options.expiresTokenStorageName) {
-        throw new Error("Auth middleware hasn't required options");
-    }
-    const isSameOrigin = !startWith(request.path, "http");
-    if (request.token) {
-        if (!isSameOrigin)
-            request.headers = {
-                ...request.headers,
-                Authorization: `Bearer ${request.token}`,
-            };
-        return;
-    }
-    if (isFetchingAccessToken)
-        await waitUntil(() => isFetchingAccessToken);
-    const expires = localStorage.getItem(options.expiresTokenStorageName);
-    let token;
-    if (!expires || Number.isNaN(+expires) || Date.now() > +expires) {
-        isFetchingAccessToken = true;
-        await getOauthTokenFromOtherWindow({
-            onlyRefreshTokenWindowQueryName: options.onlyRefreshTokenWindowQueryName,
-            onWindowOpenError: options.onWindowOpenError,
-            refreshTokenWindowUrl: options.refreshTokenWindowUrl,
-            wait: options.wait,
-            expiresTokenStorageName: options.expiresTokenStorageName,
-            closeObserveInterval: options.closeObserveInterval,
-        });
-        if (options.tokenRequest) {
-            token = await options.tokenRequest();
-            if (token != undefined && options.tokenStorageName) {
-                localStorage.setItem(options.tokenStorageName, token);
-            }
-        }
-        isFetchingAccessToken = false;
-    }
-    if (!isSameOrigin && token)
-        request.headers = {
-            ...request.headers,
-            Authorization: `Bearer ${token}`,
-        };
-};
-
-function generateMiddlewares(activeMiddlewares, middlewareOptions, customMiddlewares) {
-    const selectedMiddlewares = customMiddlewares;
-    for (const key of activeMiddlewares) {
-        switch (key) {
-            case API_MIDDLEWARES.Oauth: {
-                if (middlewareOptions.oauth && (IS_BROWSER || IS_JEST))
-                    selectedMiddlewares.push(generateOauthMiddleware(middlewareOptions.oauth));
-                continue;
-            }
-            case API_MIDDLEWARES.Logger: {
-                selectedMiddlewares.push(generateConsoleMiddleware(middlewareOptions.logger));
-                continue;
-            }
-            default: {
-                continue;
-            }
-        }
-    }
-    return function executeMiddlewares(request) {
-        return new Promise((resolve) => {
-            void (async () => {
-                for (const middleware of selectedMiddlewares) {
-                    // eslint-disable-next-line no-await-in-loop
-                    await middleware(request);
-                }
-                resolve(1);
-            })();
-        });
-    };
-}
-function generatePostMiddlewares(activePostMiddlewares, postMiddlewaresOptions, customPostMiddlewares) {
-    const selectedMiddlewares = customPostMiddlewares;
-    for (const key of activePostMiddlewares) {
-        switch (key) {
-            case POST_API_MIDDLEWARES.Logger: {
-                selectedMiddlewares.push(generateConsolePostMiddleware(postMiddlewaresOptions.logger));
-                continue;
-            }
-            default: {
-                continue;
-            }
-        }
-    }
-    return function executeMiddlewares(response) {
-        return new Promise((resolve) => {
-            void (async () => {
-                for (const middleware of selectedMiddlewares) {
-                    // eslint-disable-next-line no-await-in-loop
-                    await middleware(response);
-                }
-                resolve(1);
-            })();
-        });
-    };
-}
-
-class ResponseError extends Error {
-    status;
-    code;
-    description;
-    headers;
-    constructor({ message, status, description, code, headers }) {
-        super(message);
-        this.status = status;
-        this.description = description;
-        this.code = code;
-        this.headers = headers;
-    }
-}
-function createRequestClientInstance(options) {
-    let executeMiddlewares;
-    let executePostMiddlewares;
-    function setMiddlewares({ activeMiddlewares = [], middlewareOptions = {}, customMiddlewares = [], activePostMiddlewares = [], postMiddlewaresOptions = {}, customPostMiddlewares = [], } = {}) {
-        executeMiddlewares = generateMiddlewares(activeMiddlewares, middlewareOptions, customMiddlewares);
-        executePostMiddlewares = generatePostMiddlewares(activePostMiddlewares, postMiddlewaresOptions, customPostMiddlewares);
-    }
-    setMiddlewares(options);
-    async function handleRequest(request, responseWithStatus) {
-        if (request.delay) {
-            await wait(request.delay);
-        }
-        if (request.mock) {
-            const mock = typeof request.mock === "function" ? request.mock() : request.mock;
-            const transformedResult = request.transformIncomingData
-                ? request.transformIncomingData(mock)
-                : mock;
-            return responseWithStatus
-                ? { data: transformedResult, status: 200, headers: {} }
-                : transformedResult;
-        }
-        await executeMiddlewares(request);
-        const { method, body, path, params, headers = {} } = request;
-        const url = createURLWithParams({ baseURL: path, params });
-        const [, requestContentType] = Object.entries(headers).find(([header]) => header.toLowerCase() === "content-type") ?? [];
-        let preparedBody = body;
-        if (request.transformOutcomingData) {
-            preparedBody = request.transformOutcomingData(body);
-        }
-        if (requestContentType == undefined &&
-            !(preparedBody instanceof FormData) &&
-            preparedBody != undefined &&
-            !isString(preparedBody)) {
-            headers["content-type"] = "application/json; charset=UTF-8";
-        }
-        if ((requestContentType == undefined || requestContentType.toLowerCase().includes("json")) &&
-            preparedBody != undefined &&
-            !(preparedBody instanceof FormData) &&
-            !isString(preparedBody)) {
-            preparedBody = JSON.stringify(preparedBody);
-        }
-        const response = await options.client(url, {
-            method,
-            body: preparedBody,
-            headers: headers,
-            signal: request.signal,
-        });
-        await executePostMiddlewares(response);
-        if (!response) {
-            throw new Error("hasn't response");
-        }
-        if (!response.ok) {
-            if (response.status === 304) {
-                return responseWithStatus
-                    ? {
-                        data: undefined,
-                        status: response.status,
-                        headers: Object.fromEntries(response.headers.entries()),
-                    }
-                    : undefined;
-            }
-            if (request.defaultResponse) {
-                const defaultResponse = typeof request.defaultResponse === "function"
-                    ? request.defaultResponse()
-                    : request.defaultResponse;
-                const transformedResult = request.transformIncomingData
-                    ? request.transformIncomingData(defaultResponse)
-                    : defaultResponse;
-                return responseWithStatus
-                    ? {
-                        data: transformedResult,
-                        status: response.status,
-                        headers: Object.fromEntries(response.headers.entries()),
-                    }
-                    : transformedResult;
-            }
-            let result;
-            try {
-                const contentType = response.headers.get("content-type");
-                if (contentType?.includes?.("text")) {
-                    result = await response.text();
-                }
-                else if (contentType?.includes?.("json")) {
-                    result = await response.json();
-                }
-                else {
-                    result = await response.blob();
-                }
-            }
-            catch {
-                if (RESPONSE_DATA_SYMBOL in response)
-                    result = response[RESPONSE_DATA_SYMBOL];
-            }
-            throw new ResponseError({
-                status: response.status,
-                message: `HTTP error! Status: ${response.status}`,
-                description: result,
-                headers: Object.fromEntries(response.headers.entries()),
-            });
-        }
-        if (request.downloadFile) {
-            const data = await response.blob();
-            const mimeType = response.headers.get("content-type");
-            const fileName = response.headers.get("content-disposition");
-            if (!mimeType || !fileName)
-                throw new Error("Download Error! Empty info!");
-            if (IS_BROWSER)
-                downloadFile({
-                    data: data,
-                    fileName,
-                    mimeType,
-                });
-            return responseWithStatus
-                ? {
-                    data: data,
-                    status: response.status,
-                    headers: Object.fromEntries(response.headers.entries()),
-                }
-                : data;
-        }
-        const contentType = response.headers.get("content-type");
-        let result = undefined;
-        try {
-            if (contentType?.includes?.("text")) {
-                result = (await response.text());
-            }
-            else if (contentType?.includes?.("json")) {
-                result = (await response.json());
-            }
-            else {
-                result = (await response.blob());
-            }
-        }
-        catch { }
-        const transformedResult = request.transformIncomingData
-            ? request.transformIncomingData(result)
-            : result;
-        return responseWithStatus
-            ? {
-                data: transformedResult,
-                status: response.status,
-                headers: Object.fromEntries(response.headers.entries()),
-            }
-            : transformedResult;
-    }
-    async function requestApi(request) {
-        return handleRequest(request, false);
-    }
-    async function requestApiWithMeta(request) {
-        return handleRequest(request, true);
-    }
-    return {
-        requestApi,
-        requestApiWithMeta,
-        setMiddlewares,
-    };
-}
-
-function getColorFormat(color) {
-    if (color.startsWith("#")) {
-        return COLOR_FORMATS.Hex;
-    }
-    if (color.startsWith("rgba")) {
-        return COLOR_FORMATS.Rgba;
-    }
-    if (color.startsWith("rgb")) {
-        return COLOR_FORMATS.Rgb;
-    }
-    if (color.startsWith("hsl")) {
-        return COLOR_FORMATS.Hsl;
-    }
-}
-
-function transformHEXtoRGB(hex) {
-    return `rgb(${hex.match(/\w\w/g)?.map((x) => +`0x${x}`)})`;
-}
-
-function transformRGBtoRGBA(rgb, opacity) {
-    const code = rgb.match(/\d+/g);
-    code?.push(String(opacity / 100));
-    return `rgba(${code?.join(",")})`;
-}
-
-function transformRGBAtoRGB(rgba) {
-    const code = rgba.match(/\d+/g);
-    code?.splice(3);
-    return `rgb(${code?.join(",")})`;
-}
-
-function takeOpacityColors(color, opacities) {
-    let rgbColor = color;
-    if (!rgbColor)
-        return [];
-    if (getColorFormat(rgbColor) === COLOR_FORMATS.Hex) {
-        rgbColor = transformHEXtoRGB(rgbColor);
-    }
-    else if (getColorFormat(rgbColor) === COLOR_FORMATS.Rgba) {
-        rgbColor = transformRGBAtoRGB(rgbColor);
-    }
-    if (getColorFormat(rgbColor) !== COLOR_FORMATS.Rgb)
-        return [];
-    return [...opacities.map((opacity) => transformRGBtoRGBA(rgbColor, opacity))];
-}
-
-function transformToColor(currentColor, defaultColor = "black", defaultFormat = COLOR_FORMATS.Hex) {
-    if (!isString(currentColor))
-        return defaultColor;
-    let correctColor = currentColor;
-    if (!getColorFormat(correctColor)) {
-        switch (defaultFormat) {
-            case COLOR_FORMATS.Hex: {
-                correctColor = `#${correctColor}`;
-                break;
-            }
-            case COLOR_FORMATS.Rgb: {
-                correctColor = `rgb(${correctColor})`;
-                break;
-            }
-            case COLOR_FORMATS.Rgba: {
-                correctColor = `rgba(${correctColor})`;
-                break;
-            }
-            case COLOR_FORMATS.Hsl: {
-                correctColor = `hsl(${correctColor})`;
-                break;
-            }
-            default: {
-                correctColor = `#${correctColor}`;
-                break;
-            }
-        }
-    }
-    return correctColor;
+    return correctColor;
 }
 
 function getRandomColor() {
@@ -2068,7 +1599,570 @@ function throttle({ interval }, func) {
     return throttled;
 }
 
-exports.API_MIDDLEWARES = API_MIDDLEWARES;
+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",
+};
+class OauthState {
+    _fetching = false;
+    get fetching() {
+        return this._fetching;
+    }
+    set fetching(value) {
+        this._fetching = value;
+    }
+}
+const OAUTH_STATE = new OauthState();
+
+async function getOauthTokenFromOtherWindow(options) {
+    let waiting = true;
+    const url = new URL(typeof options.refreshTokenWindowUrl === "function"
+        ? options.refreshTokenWindowUrl()
+        : (options.refreshTokenWindowUrl ?? window.origin));
+    url.searchParams.append(options.onlyRefreshTokenWindowQueryName, "true");
+    let windowInstance = window.open(url.toString(), "_blank", "width=800,height=600,left=100,top=100");
+    windowInstance ??= window.open(url.toString(), "_blank");
+    if (windowInstance) {
+        const channel = new BroadcastChannel(options.onlyRefreshTokenWindowQueryName);
+        const windowCloseObserver = setInterval(() => {
+            if (windowInstance.closed) {
+                if (waiting) {
+                    waiting = false;
+                    channel.close();
+                    clearInterval(windowCloseObserver);
+                }
+            }
+        }, options.closeObserveInterval ?? 500);
+        channel.onmessage = () => {
+            if (waiting) {
+                waiting = false;
+                channel.close();
+                clearInterval(windowCloseObserver);
+            }
+        };
+        setTimeout(() => {
+            if (waiting) {
+                waiting = false;
+                channel.close();
+                clearInterval(windowCloseObserver);
+            }
+            if (windowInstance && !windowInstance.closed) {
+                windowInstance.close();
+            }
+        }, options.wait ?? 15000);
+    }
+    else {
+        if (options.onWindowOpenError)
+            options.onWindowOpenError();
+        waiting = false;
+        return;
+    }
+    await waitUntil(() => waiting);
+}
+async function refetchAfterOauth(options, refetch) {
+    OAUTH_STATE.fetching = true;
+    await getOauthTokenFromOtherWindow({
+        onlyRefreshTokenWindowQueryName: options.onlyRefreshTokenWindowQueryName,
+        onWindowOpenError: options.onWindowOpenError,
+        refreshTokenWindowUrl: options.refreshTokenWindowUrl,
+        wait: options.wait,
+        expiresTokenStorageName: options.expiresTokenStorageName,
+        closeObserveInterval: options.closeObserveInterval,
+    });
+    if (options.tokenRequest) {
+        const token = await options.tokenRequest();
+        if (token != undefined && options.tokenStorageName) {
+            localStorage.setItem(options.tokenStorageName, token);
+        }
+    }
+    OAUTH_STATE.fetching = false;
+    return await refetch();
+}
+function getOauthToken(options) {
+    const queries = getQueryValues([
+        options.expiresTokenQueryName,
+        options.onlyRefreshTokenWindowQueryName,
+    ]);
+    const refreshQuery = queries?.[options.onlyRefreshTokenWindowQueryName];
+    const expiresQuery = queries?.[options.expiresTokenQueryName];
+    /** Is OnlyRefresh window */
+    const isRefresh = isString(refreshQuery)
+        ? refreshQuery === "true"
+        : isArray(refreshQuery)
+            ? refreshQuery[refreshQuery.length - 1] === "true"
+            : false;
+    /** Expires token */
+    const expires = isString(expiresQuery)
+        ? expiresQuery
+        : isArray(expiresQuery)
+            ? expiresQuery[expiresQuery.length - 1]
+            : false;
+    /** OAuth flow if not expires */
+    if (!expires) {
+        window.location.replace(typeof options.oauthUrl === "function" ? options.oauthUrl() : options.oauthUrl);
+        return null;
+    }
+    localStorage.setItem(options.expiresTokenStorageName, expires);
+    /** Close if OnlyRefresh window  */
+    if (isRefresh) {
+        const channel = new BroadcastChannel(options.onlyRefreshTokenWindowQueryName);
+        channel.postMessage(true);
+        channel.close();
+        window.close();
+    }
+    /** Delete expires query */
+    if (expires) {
+        const url = new URL(window.location.href);
+        url.searchParams.delete(options.expiresTokenQueryName);
+        window.location.replace(url.toString());
+        return null;
+    }
+    return expires;
+}
+
+function createFetchClient(options) {
+    let client = options.client;
+    let oauthOptions = options.oauthOptions;
+    let beforeHandlers = options.beforeHandlers;
+    let afterHandlers = options.afterHandlers;
+    let retries = options.retries;
+    let timeout = options.timeout;
+    function recreate(options) {
+        if ("client" in options) {
+            client = options.client;
+        }
+        if ("oauthOptions" in options) {
+            oauthOptions = options.oauthOptions;
+        }
+        if ("beforeHandlers" in options) {
+            beforeHandlers = options.beforeHandlers;
+        }
+        if ("afterHandlers" in options) {
+            afterHandlers = options.afterHandlers;
+        }
+        if ("retries" in options) {
+            retries = options.retries;
+        }
+        if ("timeout" in options) {
+            timeout = options.timeout;
+        }
+    }
+    async function handleRequest(request) {
+        const timeoutController = new AbortController();
+        const requestController = new AbortController();
+        const requestTimeout = request.timeout ?? timeout;
+        const requestRetries = request.retries ?? retries;
+        try {
+            if (request.delay) {
+                await wait(request.delay);
+            }
+            if (request.mock) {
+                const mock = typeof request.mock === "function" ? request.mock() : request.mock;
+                const transformedResult = request.transformIncomingData
+                    ? request.transformIncomingData(mock)
+                    : mock;
+                return { data: transformedResult, error: null, response: null };
+            }
+            if (requestTimeout != undefined && requestTimeout != 0) {
+                setTimeout(() => {
+                    if (requestController.signal.aborted)
+                        return;
+                    timeoutController.abort();
+                }, requestTimeout);
+                timeoutController.signal.addEventListener("abort", () => requestController.abort(), {
+                    once: true,
+                    signal: requestController.signal,
+                });
+            }
+            if (request.signal) {
+                request.signal.addEventListener("abort", () => requestController.abort(), {
+                    once: true,
+                    signal: requestController.signal,
+                });
+            }
+            {
+                let handlers = [];
+                if (request.beforeHandlers) {
+                    handlers = request.beforeHandlers;
+                }
+                else if (beforeHandlers) {
+                    handlers = beforeHandlers;
+                }
+                if (request.additionalBeforeHandlers) {
+                    handlers = handlers.concat(request.additionalBeforeHandlers);
+                }
+                if (handlers.length > 0) {
+                    await executeBeforeHandlers(handlers, request);
+                }
+            }
+            const { method, body, path, queries, headers = {}, refetchNoAuth = true } = request;
+            const url = createURLWithQueries({ baseURL: path, params: queries });
+            let [, requestContentType] = Object.entries(headers).find(([header]) => header.toLowerCase() === "content-type") ?? [];
+            if (isArray(requestContentType)) {
+                requestContentType = requestContentType[0];
+            }
+            let preparedBody = body;
+            if (request.transformOutcomingData) {
+                preparedBody = request.transformOutcomingData(body);
+            }
+            if (requestContentType == undefined &&
+                !(preparedBody instanceof FormData) &&
+                preparedBody != undefined &&
+                !isString(preparedBody)) {
+                headers["content-type"] = "application/json; charset=UTF-8";
+            }
+            if ((requestContentType == undefined || requestContentType.toLowerCase().includes("json")) &&
+                preparedBody != undefined &&
+                !(preparedBody instanceof FormData) &&
+                !isString(preparedBody)) {
+                preparedBody = JSON.stringify(preparedBody);
+            }
+            const response = await client(url, {
+                method,
+                body: preparedBody,
+                headers: headers,
+                signal: requestController.signal,
+                cache: request.cache,
+                credentials: request.credentials,
+                integrity: request.integrity,
+                keepalive: request.keepalive,
+                mode: request.mode,
+                priority: request.priority,
+                redirect: request.redirect,
+                referrer: request.referrer,
+                referrerPolicy: request.referrerPolicy,
+                compress: request.compress,
+                follow: request.follow,
+            });
+            {
+                let handlers = [];
+                if (request.afterHandlers) {
+                    handlers = request.afterHandlers;
+                }
+                else if (afterHandlers) {
+                    handlers = afterHandlers;
+                }
+                if (request.additionalAfterHandlers) {
+                    handlers = handlers.concat(request.additionalAfterHandlers);
+                }
+                if (handlers.length > 0) {
+                    await executeAfterHandlers(handlers, request, response);
+                }
+            }
+            if (!response.ok) {
+                if (response.status === 304) {
+                    const error = new ResponseError({
+                        message: REQUEST_ERROR.CACHE_ERROR,
+                        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 };
+                }
+                if (response.status === 401 && refetchNoAuth && oauthOptions) {
+                    return await refetchAfterOauth(oauthOptions, () => handleRequest({ ...request, refetchNoAuth: false }));
+                }
+                if (request.defaultResponse) {
+                    const defaultResponse = typeof request.defaultResponse === "function"
+                        ? request.defaultResponse()
+                        : request.defaultResponse;
+                    const transformedResult = request.transformIncomingData
+                        ? request.transformIncomingData(defaultResponse)
+                        : defaultResponse;
+                    return {
+                        data: transformedResult,
+                        error: null,
+                        response: null,
+                    };
+                }
+                if (requestRetries && requestRetries.length > 0) {
+                    await wait(requestRetries[0]);
+                    return await handleRequest({ ...request, retries: requestRetries.slice(1) });
+                }
+                let result;
+                try {
+                    const contentType = response.headers.get("content-type");
+                    if (RESPONSE_DATA_SYMBOL in response) {
+                        result = response[RESPONSE_DATA_SYMBOL];
+                    }
+                    else if (contentType?.includes?.("text")) {
+                        result = await response.text();
+                    }
+                    else if (contentType?.includes?.("json")) {
+                        result = await response.json();
+                    }
+                    else {
+                        result = await response.blob();
+                    }
+                }
+                catch { }
+                const error = new ResponseError({
+                    status: response.status,
+                    message: REQUEST_ERROR.HTTP_ERROR,
+                    description: result,
+                    headers: Object.fromEntries(response.headers.entries()),
+                });
+                request.onError?.(REQUEST_ERROR.HTTP_ERROR, error);
+                return {
+                    data: error,
+                    error: REQUEST_ERROR.HTTP_ERROR,
+                    response,
+                };
+            }
+            if (request.download) {
+                const data = await response.blob();
+                const mimeType = response.headers.get("content-type");
+                const fileName = response.headers.get("content-disposition");
+                if (!mimeType) {
+                    console.warn("couldn't download file because content-type header is not exist");
+                }
+                else if (!fileName) {
+                    console.warn("couldn't download file because content-disposition header is not exist");
+                }
+                if (IS_BROWSER && mimeType && fileName)
+                    downloadFile({
+                        data: data,
+                        fileName,
+                        mimeType,
+                    });
+                return {
+                    data: data,
+                    error: null,
+                    response,
+                };
+            }
+            const contentType = response.headers.get("content-type");
+            let result = undefined;
+            if (RESPONSE_DATA_SYMBOL in response) {
+                result = response[RESPONSE_DATA_SYMBOL];
+            }
+            else if (contentType?.includes?.("text")) {
+                result = (await response.text());
+            }
+            else if (contentType?.includes?.("json")) {
+                result = (await response.json());
+            }
+            else {
+                result = (await response.blob());
+            }
+            const transformedResult = request.transformIncomingData
+                ? request.transformIncomingData(result)
+                : result;
+            return {
+                data: transformedResult,
+                error: null,
+                response,
+            };
+        }
+        catch (err) {
+            if (request.defaultResponse) {
+                const defaultResponse = typeof request.defaultResponse === "function"
+                    ? request.defaultResponse()
+                    : request.defaultResponse;
+                const transformedResult = request.transformIncomingData
+                    ? request.transformIncomingData(defaultResponse)
+                    : defaultResponse;
+                return {
+                    data: transformedResult,
+                    error: null,
+                    response: null,
+                };
+            }
+            if (requestRetries && requestRetries.length > 0 && request?.signal?.aborted !== true) {
+                await wait(requestRetries[0]);
+                return await handleRequest({ ...request, retries: requestRetries.slice(1) });
+            }
+            if (err instanceof TypeError) {
+                const error = new ResponseError({
+                    message: REQUEST_ERROR.NETWORK_ERROR,
+                    status: 0,
+                    description: String(err.message),
+                });
+                request.onError?.(REQUEST_ERROR.NETWORK_ERROR, error);
+                return { data: error, error: REQUEST_ERROR.NETWORK_ERROR, response: null };
+            }
+            if (err instanceof Error && err.name === "AbortError") {
+                if (timeoutController.signal.aborted) {
+                    const error = new ResponseError({
+                        message: REQUEST_ERROR.TIMEOUT_ERROR,
+                        status: 0,
+                    });
+                    request.onError?.(REQUEST_ERROR.TIMEOUT_ERROR, error);
+                    return { data: error, error: REQUEST_ERROR.TIMEOUT_ERROR, response: null };
+                }
+                const error = new ResponseError({
+                    message: REQUEST_ERROR.ABORT_ERROR,
+                    status: 0,
+                });
+                request.onError?.(REQUEST_ERROR.ABORT_ERROR, error);
+                return { data: error, error: REQUEST_ERROR.ABORT_ERROR, response: null };
+            }
+            const error = new ResponseError({
+                message: REQUEST_ERROR.UNKNOWN_ERROR,
+                status: 0,
+                description: String(err),
+            });
+            request.onError?.(REQUEST_ERROR.UNKNOWN_ERROR, error);
+            return { data: error, error: REQUEST_ERROR.UNKNOWN_ERROR, response: null };
+        }
+        finally {
+            requestController.abort();
+        }
+    }
+    async function requestWithArrayResponse(request) {
+        const response = await handleRequest(request);
+        return [response.data, response.error, response.response];
+    }
+    async function requestWithObjectResponse(request) {
+        return handleRequest(request);
+    }
+    return {
+        requestWithArrayResponse,
+        requestWithObjectResponse,
+        recreate,
+    };
+}
+function executeBeforeHandlers(handlers, request) {
+    return new Promise((resolve) => {
+        void (async () => {
+            for (const handler of handlers) {
+                // eslint-disable-next-line no-await-in-loop
+                await handler(request);
+            }
+            resolve(1);
+        })();
+    });
+}
+function executeAfterHandlers(handlers, request, response) {
+    return new Promise((resolve) => {
+        void (async () => {
+            for (const handler of handlers) {
+                // eslint-disable-next-line no-await-in-loop
+                await handler(request, response);
+            }
+            resolve(1);
+        })();
+    });
+}
+
+function loggerAfterHandler(options = {}) {
+    return (request, response) => {
+        return new Promise((resolve) => {
+            void (async function logger() {
+                try {
+                    if (!response ||
+                        (options.filter && !options.filter(response)) ||
+                        (options.filterStatus && !options.filterStatus(response.status)) ||
+                        (options.filterUrl && !options.filterUrl(response.url)) ||
+                        (options.filterHeaders && !options.filterHeaders(response.headers))) {
+                        resolve(true);
+                        return;
+                    }
+                    const contentType = response.headers.get("content-type");
+                    let result;
+                    if (contentType?.includes?.("text")) {
+                        result = await response.text();
+                    }
+                    else if (contentType?.includes?.("json")) {
+                        result = await response.json();
+                    }
+                    else {
+                        result = await response.blob();
+                    }
+                    Object.defineProperty(response, RESPONSE_DATA_SYMBOL, {
+                        value: result,
+                        writable: false,
+                        enumerable: false,
+                        configurable: true,
+                    });
+                    console.log({
+                        url: response.url,
+                        status: response.status,
+                        headers: response.headers,
+                        body: result,
+                    });
+                    resolve(true);
+                }
+                catch {
+                    if (response) {
+                        console.log({ url: response.url, status: response.status, headers: response.headers });
+                    }
+                    resolve(true);
+                }
+            })().finally(() => {
+                resolve(true);
+            });
+        });
+    };
+}
+
+function loggerBeforeHandler(options = {}) {
+    return (request) => {
+        return new Promise((resolve) => {
+            if ((options.filter &&
+                !options.filter(request)) ||
+                (options.filterHeaders && !options.filterHeaders(request.headers)) ||
+                (options.filterMethod && !options.filterMethod(request.method)) ||
+                (options.filterParams && !options.filterParams(request.queries)) ||
+                (options.filterPath && !options.filterPath(request.path))) {
+                resolve(true);
+                return;
+            }
+            // eslint-disable-next-line no-console
+            console.log(request);
+            resolve(true);
+        });
+    };
+}
+
+const oauthBeforeHandler = (options) => async (request) => {
+    if (!options.expiresTokenStorageName) {
+        throw new Error("Auth middleware hasn't required options");
+    }
+    const isSameOrigin = !startWith(request.path, "http");
+    if (request.token) {
+        if (!isSameOrigin)
+            request.headers = {
+                ...request.headers,
+                Authorization: `Bearer ${request.token}`,
+            };
+        return;
+    }
+    if (OAUTH_STATE.fetching)
+        await waitUntil(() => OAUTH_STATE.fetching);
+    const expires = localStorage.getItem(options.expiresTokenStorageName);
+    let token;
+    if (!expires || Number.isNaN(+expires) || Date.now() > +expires) {
+        OAUTH_STATE.fetching = true;
+        await getOauthTokenFromOtherWindow({
+            onlyRefreshTokenWindowQueryName: options.onlyRefreshTokenWindowQueryName,
+            onWindowOpenError: options.onWindowOpenError,
+            refreshTokenWindowUrl: options.refreshTokenWindowUrl,
+            wait: options.wait,
+            expiresTokenStorageName: options.expiresTokenStorageName,
+            closeObserveInterval: options.closeObserveInterval,
+        });
+        if (options.tokenRequest) {
+            token = await options.tokenRequest();
+            if (token != undefined && options.tokenStorageName) {
+                localStorage.setItem(options.tokenStorageName, token);
+            }
+        }
+        OAUTH_STATE.fetching = false;
+    }
+    if (!isSameOrigin && token)
+        request.headers = {
+            ...request.headers,
+            Authorization: `Bearer ${token}`,
+        };
+};
+
 exports.COLOR_FORMATS = COLOR_FORMATS;
 exports.DATE_TYPES = DATE_TYPES;
 exports.FIELD_TYPES = FIELD_TYPES;
@@ -2078,17 +2172,19 @@ exports.IS_DENO = IS_DENO;
 exports.IS_JEST = IS_JEST;
 exports.IS_NODE = IS_NODE;
 exports.IS_WEB_WORKER = IS_WEB_WORKER;
-exports.POST_API_MIDDLEWARES = POST_API_MIDDLEWARES;
+exports.OAUTH_STATE = OAUTH_STATE;
+exports.REQUEST_ERROR = REQUEST_ERROR;
+exports.RESPONSE_DATA_SYMBOL = RESPONSE_DATA_SYMBOL;
 exports.ResponseError = ResponseError;
 exports.arrayToMapByKey = arrayToMapByKey;
 exports.buildQueryString = buildQueryString;
 exports.checkType = checkType;
 exports.cloneDeep = cloneDeep;
 exports.copyToClipboard = copyToClipboard;
+exports.createFetchClient = createFetchClient;
 exports.createGlobalId = createGlobalId;
 exports.createLocalIdGenerator = createLocalIdGenerator;
-exports.createRequestClientInstance = createRequestClientInstance;
-exports.createURLWithParams = createURLWithParams;
+exports.createURLWithQueries = createURLWithQueries;
 exports.dateDifference = dateDifference;
 exports.dateFormat = dateFormat;
 exports.debounce = debounce;
@@ -2101,7 +2197,6 @@ exports.downloadJson = downloadJson;
 exports.execAnimation = execAnimation;
 exports.extractQueries = extractQueries;
 exports.fieldViewFormat = fieldViewFormat;
-exports.getAuthUser = getAuthUser;
 exports.getByPath = getByPath;
 exports.getCallerFunctionName = getCallerFunctionName;
 exports.getColorFormat = getColorFormat;
@@ -2133,9 +2228,13 @@ exports.isYesterday = isYesterday;
 exports.joinPaths = joinPaths;
 exports.jsonParse = jsonParse;
 exports.limitStreamOfRequests = limitStreamOfRequests;
+exports.loggerAfterHandler = loggerAfterHandler;
+exports.loggerBeforeHandler = loggerBeforeHandler;
+exports.oauthBeforeHandler = oauthBeforeHandler;
 exports.randomNumber = randomNumber;
 exports.randomString = randomString;
 exports.readFile = readFile;
+exports.refetchAfterOauth = refetchAfterOauth;
 exports.setByPath = setByPath;
 exports.speedTest = speedTest;
 exports.startWith = startWith;
@@ -2151,7 +2250,6 @@ exports.transformToNumber = transformToNumber;
 exports.translit = translit;
 exports.trimUrl = trimUrl;
 exports.type = type;
-exports.updateAuthUser = updateAuthUser;
 exports.wait = wait;
 exports.waitUntil = waitUntil;
 //# sourceMappingURL=index.cjs.map