@krainovsd/js-helpers 0.14.13 → 0.15.1

package/lib/cjs/index.cjs

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const get = require('lodash/get');
 const dayjs = require('dayjs');
 const todayPlugin = require('dayjs/plugin/isToday');
 const tomorrowPlugin = require('dayjs/plugin/isTomorrow');
 const yesterdayPlugin = require('dayjs/plugin/isYesterday');
+const get = require('lodash/get');
 const set = require('lodash/set');
 
 const DATE_TYPES = {
@@ -19,8 +19,7 @@ const DATE_TYPES = {
 };
 
 const API_MIDDLEWARES = {
-    Auth: "auth",
-    AuthNoRefresh: "authNoRefresh",
+    Oauth: "oauth",
     Logger: "logger",
 };
 const POST_API_MIDDLEWARES = {
@@ -71,61 +70,6 @@ const waitUntil = (condition, checkInterval = 100) => {
     });
 };
 
-function checkType(value, condition) {
-    if (condition) {
-        return true;
-    }
-    return false;
-}
-
-function isArray(value) {
-    return Boolean(value && Array.isArray(value));
-}
-
-function isBoolean(value) {
-    return typeof value === "boolean";
-}
-
-function isNumber(value) {
-    return typeof value === "number" && !Number.isNaN(value);
-}
-
-function isString(value) {
-    return typeof value === "string";
-}
-
-function isId(value) {
-    return isNumber(value) || isString(value);
-}
-
-function isNull(value) {
-    return value === null;
-}
-
-function isNullable(value) {
-    return typeof value === "undefined" || value === null;
-}
-
-function isObject(value) {
-    return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
-function isUndefined(value) {
-    return typeof value === "undefined";
-}
-
-function isDate(value) {
-    if (value instanceof Date)
-        return !Number.isNaN(value.valueOf());
-    return false;
-}
-
-function getByPath(data, path, defaultValue) {
-    if ((!isObject(data) && !isArray(data)) || !isString(path))
-        return defaultValue;
-    return get(data, path, defaultValue);
-}
-
 function dateDifference({ firstDate, float = false, secondDate = new Date(), type, }) {
     const first = dayjs(firstDate);
     return first.diff(secondDate, type, float);
@@ -222,6 +166,60 @@ function isYesterday(date) {
     }
 }
 
+function checkType(value, condition) {
+    if (condition) {
+        return true;
+    }
+    return false;
+}
+
+function isArray(value) {
+    return Boolean(value && Array.isArray(value));
+}
+
+function isBoolean(value) {
+    return typeof value === "boolean";
+}
+
+function isNumber(value) {
+    return typeof value === "number" && !Number.isNaN(value);
+}
+
+function isString(value) {
+    return typeof value === "string";
+}
+
+function isId(value) {
+    return isNumber(value) || isString(value);
+}
+
+function isNull(value) {
+    return value === null;
+}
+
+function isNullable(value) {
+    return typeof value === "undefined" || value === null;
+}
+
+function isObject(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function isUndefined(value) {
+    return typeof value === "undefined";
+}
+
+function isDate(value) {
+    if (value instanceof Date)
+        return !Number.isNaN(value.valueOf());
+    return false;
+}
+
+function isPrimitive(value) {
+    const type = typeof value;
+    return value == undefined || (type != "object" && type != "function");
+}
+
 function dateFormat(date, format) {
     const correctDate = new Date(date);
     if (!isDate(correctDate))
@@ -274,17 +272,6 @@ function fieldViewFormat(field, type = "string") {
     }
 }
 
-function setByPath(data, path, value) {
-    try {
-        if (!isObject(data) && !isArray(data))
-            throw new Error("bad data");
-        set(data, path, value);
-    }
-    catch (error) {
-        console.warn(error);
-    }
-}
-
 function jsonParse(json) {
     if (!isString(json))
         return null;
@@ -356,6 +343,23 @@ function arrayToMapByKey(array, key) {
     return map;
 }
 
+function getByPath(data, path, defaultValue) {
+    if ((!isObject(data) && !isArray(data)) || !isString(path))
+        return defaultValue;
+    return get(data, path, defaultValue);
+}
+
+function setByPath(data, path, value) {
+    try {
+        if (!isObject(data) && !isArray(data))
+            throw new Error("bad data");
+        set(data, path, value);
+    }
+    catch (error) {
+        console.warn(error);
+    }
+}
+
 function syncObjectValues(oldObj, newObj, exception = []) {
     for (const field in newObj) {
         if (exception.includes(field))
@@ -667,6 +671,18 @@ function createLocalIdGenerator() {
     };
 }
 
+function declination(value, words) {
+    value = Math.abs(value) % 100;
+    const num = value % 10;
+    if (value > 10 && value < 20)
+        return words[2];
+    if (num > 1 && num < 5)
+        return words[1];
+    if (num == 1)
+        return words[0];
+    return words[2];
+}
+
 function downloadFile({ data, fileName, mimeType }) {
     if (!IS_BROWSER && !IS_JEST)
         return null;
@@ -1242,93 +1258,179 @@ function execAnimation(element, className, autoCloseDelay = 700) {
     });
 }
 
-const RESPONSE_DATA_SYMBOL = Symbol("response data");
-
-async function updateAuthToken(options) {
-    let token = localStorage.getItem(options.tokenStorageName);
-    const expires = localStorage.getItem(options.expiresTokenStorageName);
-    if (!token || !expires || Date.now() > +expires) {
-        token = await (options.tokenRequest ? options.tokenRequest() : getAuthToken(options));
-        if (isNull(token)) {
-            return void window.location.replace(typeof options.oauthUrl === "function" ? options.oauthUrl() : options.oauthUrl);
-        }
-        if (isUndefined(token)) {
-            return void window.location.replace(typeof options.errorUrl === "function" ? options.errorUrl() : options.errorUrl);
-        }
-    }
-    return token;
-}
-async function getAuthToken(options) {
-    let status = 0;
-    try {
-        const response = await fetch(options.authTokenUrl, {
-            method: "GET",
-        });
-        status = response.status;
-        if (!response.ok) {
-            throw new Error(`HTTP error! Status: ${response.status}`);
+function copyToClipboard(textToCopy) {
+    return new Promise((resolve) => {
+        if (!IS_BROWSER && !IS_JEST) {
+            resolve(false);
+            return;
         }
-        const result = (await response.json());
         try {
-            const { expires, token } = transformData(result, options.pathToToken, options.pathToTokenExpires);
-            localStorage.setItem(options.expiresTokenStorageName, expires);
-            localStorage.setItem(options.tokenStorageName, token);
-            return token;
+            if (navigator.clipboard && window.isSecureContext) {
+                navigator.clipboard
+                    .writeText(textToCopy)
+                    .then(() => resolve(true))
+                    .catch(() => resolve(false));
+                return;
+            }
+            const textArea = document.createElement("textarea");
+            textArea.value = textToCopy;
+            textArea.style.position = "fixed";
+            textArea.style.left = "-999999px";
+            textArea.style.top = "-999999px";
+            document.body.appendChild(textArea);
+            textArea.focus();
+            textArea.select();
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            const result = document.execCommand("copy");
+            textArea.remove();
+            resolve(result);
         }
         catch {
-            return undefined;
+            resolve(false);
         }
-    }
-    catch {
-        if (status >= 500)
-            return undefined;
-        return null;
-    }
+    });
 }
-function transformData(data, pathToToken, pathToTokenExpires) {
-    if (!isObject(data))
-        throw new Error("Bad response data");
-    const token = getByPath(data, pathToToken);
-    const expiresToken = getByPath(data, pathToTokenExpires);
-    if ((!isString(expiresToken) && !isNumber(expiresToken)) || !isString(token))
-        throw new Error("Bad response data");
-    return {
-        expires: String(expiresToken),
-        token,
+
+function extractQueries() {
+    const queryMap = {};
+    if (!IS_BROWSER && !IS_JEST)
+        return queryMap;
+    const queryString = document.location.search;
+    queryString
+        .replace(/^\?/, "")
+        .split("&")
+        .forEach((query) => {
+        const [key, value] = query.split("=", 2);
+        queryMap[key] ??= [];
+        const prev = queryMap[key];
+        prev.push(value);
+    });
+    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 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);
+            });
+        });
     };
 }
-async function getAuthTokenNoRefresh(options) {
-    let waiting = true;
+
+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());
-    if (!windowInstance) {
+    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;
     }
-    const channel = new BroadcastChannel(options.onlyRefreshTokenWindowQueryName);
-    channel.onmessage = () => {
-        if (waiting) {
-            waiting = false;
-            channel.close();
-        }
-    };
-    setTimeout(() => {
-        if (waiting) {
-            waiting = false;
-            channel.close();
-        }
-        if (windowInstance && !windowInstance.closed) {
-            windowInstance.close();
-        }
-    }, 15000);
     await waitUntil(() => waiting);
 }
-function updateAuthTokenNoRefresh(options) {
+function getOauthToken(options) {
     let expires = localStorage.getItem(options.expiresTokenStorageName);
     if (!expires || Number.isNaN(+expires) || Date.now() > +expires)
         expires = null;
@@ -1409,50 +1511,8 @@ async function getAuthUser(options) {
     }
 }
 
-let isFetchingAccessToken$1 = false;
-const generateAuthMiddleWare = (options) => async (request) => {
-    if (!options.authTokenUrl ||
-        !options.oauthUrl ||
-        !options.expiresTokenStorageName ||
-        !options.tokenStorageName ||
-        !options.pathToTokenExpires ||
-        !options.pathToToken ||
-        !options.errorUrl) {
-        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$1)
-        await waitUntil(() => isFetchingAccessToken$1);
-    const expires = localStorage.getItem(options.expiresTokenStorageName);
-    let token = localStorage.getItem(options.tokenStorageName);
-    if (!expires || Date.now() > +expires || !token) {
-        isFetchingAccessToken$1 = true;
-        token = await (options.tokenRequest ? options.tokenRequest() : getAuthToken(options));
-        isFetchingAccessToken$1 = false;
-        if (isNull(token)) {
-            return void window.location.replace(typeof options.oauthUrl === "function" ? options.oauthUrl() : options.oauthUrl);
-        }
-        if (isUndefined(token)) {
-            return void window.location.replace(typeof options.errorUrl === "function" ? options.errorUrl() : options.errorUrl);
-        }
-    }
-    if (!isSameOrigin)
-        request.headers = {
-            ...request.headers,
-            Authorization: `Bearer ${token}`,
-        };
-};
-
 let isFetchingAccessToken = false;
-const generateAuthNoRefreshMiddleWare = (options) => async (request) => {
+const generateOauthMiddleware = (options) => async (request) => {
     if (!options.oauthUrl || !options.expiresTokenStorageName || !options.errorUrl) {
         throw new Error("Auth middleware hasn't required options");
     }
@@ -1468,12 +1528,25 @@ const generateAuthNoRefreshMiddleWare = (options) => async (request) => {
     if (isFetchingAccessToken)
         await waitUntil(() => isFetchingAccessToken);
     const expires = localStorage.getItem(options.expiresTokenStorageName);
+    let token;
     if (!expires || Number.isNaN(+expires) || Date.now() > +expires) {
         isFetchingAccessToken = true;
-        await (options.tokenRequest ? options.tokenRequest() : getAuthTokenNoRefresh(options));
+        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;
     }
-    const token = options.tokenStorageName ? localStorage.getItem(options.tokenStorageName) : null;
     if (!isSameOrigin && token)
         request.headers = {
             ...request.headers,
@@ -1481,88 +1554,13 @@ const generateAuthNoRefreshMiddleWare = (options) => async (request) => {
         };
 };
 
-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 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 generateMiddlewares(activeMiddlewares, middlewareOptions, customMiddlewares) {
     const selectedMiddlewares = customMiddlewares;
     for (const key of activeMiddlewares) {
         switch (key) {
-            case API_MIDDLEWARES.Auth: {
-                if (middlewareOptions.auth && (IS_BROWSER || IS_JEST))
-                    selectedMiddlewares.push(generateAuthMiddleWare(middlewareOptions.auth));
-                continue;
-            }
-            case API_MIDDLEWARES.AuthNoRefresh: {
-                if (middlewareOptions.authNoRefresh && (IS_BROWSER || IS_JEST))
-                    selectedMiddlewares.push(generateAuthNoRefreshMiddleWare(middlewareOptions.authNoRefresh));
+            case API_MIDDLEWARES.Oauth: {
+                if (middlewareOptions.oauth && (IS_BROWSER || IS_JEST))
+                    selectedMiddlewares.push(generateOauthMiddleware(middlewareOptions.oauth));
                 continue;
             }
             case API_MIDDLEWARES.Logger: {
@@ -1865,6 +1863,211 @@ function getRandomColor() {
     return `#${randomColor.padStart(6, "0")}`;
 }
 
+function type(value) {
+    return value === null
+        ? "Null"
+        : value === undefined
+            ? "Undefined"
+            : Object.prototype.toString.call(value).slice(8, -1);
+}
+
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+function cloneDeep(value, map) {
+    map ??= new Map();
+    // this avoids the slower switch with a quick if decision removing some milliseconds in each run.
+    if (isPrimitive(value)) {
+        return value;
+    }
+    function copy(copiedValue) {
+        // Check for circular and same references on the object graph and return its corresponding clone.
+        const cachedCopy = map.get(value);
+        if (cachedCopy) {
+            return cachedCopy;
+        }
+        map.set(value, copiedValue);
+        for (const key in value) {
+            if (Object.hasOwn(value, key)) {
+                copiedValue[key] = cloneDeep(value[key], map);
+            }
+        }
+        return copiedValue;
+    }
+    switch (type(value)) {
+        case "Object":
+            return copy(Object.create(Object.getPrototypeOf(value)));
+        case "Array":
+            return copy(Array(value.length));
+        case "Date":
+            return new Date(value.valueOf());
+        case "RegExp":
+            return cloneRegExp(value);
+        case "Int8Array":
+        case "Uint8Array":
+        case "Uint8ClampedArray":
+        case "Int16Array":
+        case "Uint16Array":
+        case "Int32Array":
+        case "Uint32Array":
+        case "Float32Array":
+        case "Float64Array":
+        case "BigInt64Array":
+        case "BigUint64Array":
+            return value.slice();
+        default:
+            return value;
+    }
+}
+function cloneRegExp(pattern) {
+    return new RegExp(pattern.source, pattern.flags
+        ? pattern.flags
+        : (pattern.global ? "g" : "") +
+            (pattern.ignoreCase ? "i" : "") +
+            (pattern.multiline ? "m" : "") +
+            (pattern.sticky ? "y" : "") +
+            (pattern.unicode ? "u" : "") +
+            (pattern.dotAll ? "s" : ""));
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function debounce({ delay }, func) {
+    let timer;
+    let active = true;
+    const debounced = (...args) => {
+        if (active) {
+            clearTimeout(timer);
+            timer = setTimeout(() => {
+                if (active) {
+                    func(...args);
+                }
+                timer = undefined;
+            }, delay);
+        }
+        else {
+            func(...args);
+        }
+    };
+    debounced.isPending = () => {
+        return timer !== undefined;
+    };
+    debounced.cancel = () => {
+        active = false;
+    };
+    debounced.flush = (...args) => {
+        func(...args);
+    };
+    return debounced;
+}
+
+function difference(first, second) {
+    let idx = 0;
+    const out = [];
+    const toFilterOut = new Set();
+    for (let i = 0; i < second.length; i += 1) {
+        toFilterOut.add(second[i]);
+    }
+    while (idx < first.length) {
+        if (!toFilterOut.has(first[idx])) {
+            out[out.length] = first[idx];
+        }
+        idx += 1;
+    }
+    return out;
+}
+
+function differenceBy(first, second, key) {
+    let idx = 0;
+    const out = [];
+    const toFilterOut = new Set();
+    for (let i = 0; i < second.length; i += 1) {
+        toFilterOut.add(second[i][key]);
+    }
+    while (idx < first.length) {
+        if (!toFilterOut.has(first[idx][key])) {
+            out.push(first[idx]);
+        }
+        idx += 1;
+    }
+    return out;
+}
+
+function differenceWith(first, second, extractPrimitive) {
+    let idx = 0;
+    const out = [];
+    const toFilterOut = new Set();
+    for (let i = 0; i < second.length; i += 1) {
+        toFilterOut.add(extractPrimitive(second[i]));
+    }
+    while (idx < first.length) {
+        if (!toFilterOut.has(extractPrimitive(first[idx]))) {
+            out.push(first[idx]);
+        }
+        idx += 1;
+    }
+    return out;
+}
+
+function isEqual(aVal, bVal) {
+    if (aVal === bVal)
+        return true;
+    if (aVal == undefined ||
+        bVal == undefined ||
+        typeof aVal !== "object" ||
+        typeof bVal !== "object") {
+        return aVal === bVal;
+    }
+    if (aVal instanceof Date && bVal instanceof Date) {
+        return aVal.getTime() === bVal.getTime();
+    }
+    if (aVal instanceof RegExp && bVal instanceof RegExp) {
+        return aVal.toString() === bVal.toString();
+    }
+    if (aVal.constructor !== bVal.constructor) {
+        return false;
+    }
+    if (Array.isArray(aVal) && Array.isArray(bVal)) {
+        if (aVal.length !== bVal.length)
+            return false;
+        for (let i = 0; i < aVal.length; i++) {
+            if (!isEqual(aVal[i], bVal[i]))
+                return false;
+        }
+        return true;
+    }
+    if (isObject(aVal) && isObject(bVal)) {
+        const keysA = Object.keys(aVal);
+        const keysB = Object.keys(bVal);
+        if (keysA.length !== keysB.length)
+            return false;
+        for (const key of keysA) {
+            if (!keysB.includes(key))
+                return false;
+            if (!isEqual(aVal[key], bVal[key]))
+                return false;
+        }
+    }
+    return true;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+function throttle({ interval }, func) {
+    let ready = true;
+    let timer;
+    const throttled = (...args) => {
+        if (!ready)
+            return;
+        func(...args);
+        ready = false;
+        timer = setTimeout(() => {
+            ready = true;
+            timer = undefined;
+        }, interval);
+    };
+    throttled.isThrottled = () => {
+        return timer !== undefined;
+    };
+    return throttled;
+}
+
 exports.API_MIDDLEWARES = API_MIDDLEWARES;
 exports.COLOR_FORMATS = COLOR_FORMATS;
 exports.DATE_TYPES = DATE_TYPES;
@@ -1880,24 +2083,32 @@ exports.ResponseError = ResponseError;
 exports.arrayToMapByKey = arrayToMapByKey;
 exports.buildQueryString = buildQueryString;
 exports.checkType = checkType;
+exports.cloneDeep = cloneDeep;
+exports.copyToClipboard = copyToClipboard;
 exports.createGlobalId = createGlobalId;
 exports.createLocalIdGenerator = createLocalIdGenerator;
 exports.createRequestClientInstance = createRequestClientInstance;
 exports.createURLWithParams = createURLWithParams;
 exports.dateDifference = dateDifference;
 exports.dateFormat = dateFormat;
+exports.debounce = debounce;
+exports.declination = declination;
+exports.difference = difference;
+exports.differenceBy = differenceBy;
+exports.differenceWith = differenceWith;
 exports.downloadFile = downloadFile;
 exports.downloadJson = downloadJson;
 exports.execAnimation = execAnimation;
+exports.extractQueries = extractQueries;
 exports.fieldViewFormat = fieldViewFormat;
-exports.getAuthToken = getAuthToken;
-exports.getAuthTokenNoRefresh = getAuthTokenNoRefresh;
 exports.getAuthUser = getAuthUser;
 exports.getByPath = getByPath;
 exports.getCallerFunctionName = getCallerFunctionName;
 exports.getColorFormat = getColorFormat;
 exports.getDateByRules = getDateByRules;
 exports.getFileNameFromHeader = getFileNameFromHeader;
+exports.getOauthToken = getOauthToken;
+exports.getOauthTokenFromOtherWindow = getOauthTokenFromOtherWindow;
 exports.getQueryValues = getQueryValues;
 exports.getRandomColor = getRandomColor;
 exports.getToday = getToday;
@@ -1907,11 +2118,13 @@ exports.getYesterday = getYesterday;
 exports.isArray = isArray;
 exports.isBoolean = isBoolean;
 exports.isDate = isDate;
+exports.isEqual = isEqual;
 exports.isId = isId;
 exports.isNull = isNull;
 exports.isNullable = isNullable;
 exports.isNumber = isNumber;
 exports.isObject = isObject;
+exports.isPrimitive = isPrimitive;
 exports.isString = isString;
 exports.isToday = isToday;
 exports.isTomorrow = isTomorrow;
@@ -1928,6 +2141,7 @@ exports.speedTest = speedTest;
 exports.startWith = startWith;
 exports.syncObjectValues = syncObjectValues;
 exports.takeOpacityColors = takeOpacityColors;
+exports.throttle = throttle;
 exports.transformHEXtoRGB = transformHEXtoRGB;
 exports.transformRGBAtoRGB = transformRGBAtoRGB;
 exports.transformRGBtoRGBA = transformRGBtoRGBA;
@@ -1936,8 +2150,7 @@ exports.transformToDayjs = transformToDayjs;
 exports.transformToNumber = transformToNumber;
 exports.translit = translit;
 exports.trimUrl = trimUrl;
-exports.updateAuthToken = updateAuthToken;
-exports.updateAuthTokenNoRefresh = updateAuthTokenNoRefresh;
+exports.type = type;
 exports.updateAuthUser = updateAuthUser;
 exports.wait = wait;
 exports.waitUntil = waitUntil;