@krainovsd/js-helpers 0.3.2 → 0.3.4

package/lib/cjs/index.cjs

@@ -0,0 +1,841 @@
+'use strict';
+
+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 set = require('lodash/set');
+
+const DATE_TYPES = {
+    Days: "days",
+    Months: "months",
+    Years: "years",
+    Seconds: "seconds",
+    Minutes: "minutes",
+    Hours: "hours",
+};
+
+const API_MIDDLEWARES = {
+    Auth: "auth",
+    Logger: "logger",
+};
+
+/* eslint-disable no-restricted-globals */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+const IS_JEST = typeof process != "undefined" && process.env.JEST_WORKER_ID !== undefined;
+const IS_BUN = typeof process !== "undefined" && process.versions != null && process.versions.bun != null;
+const IS_DENO = // @ts-expect-error
+ typeof Deno !== "undefined" &&
+    // @ts-expect-error
+    typeof Deno.version !== "undefined" &&
+    // @ts-expect-error
+    typeof Deno.version.deno !== "undefined";
+const IS_NODE = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+const IS_WEB_WORKER = typeof self === "object" &&
+    self.constructor &&
+    self.constructor.name === "DedicatedWorkerGlobalScope";
+const IS_BROWSER = typeof window !== "undefined" && typeof window.document !== "undefined";
+
+const COLOR_FORMATS = {
+    Hex: "HEX",
+    Rgb: "RGB",
+    Rgba: "RGBA",
+    Hsl: "HSL",
+};
+
+const FIELD_TYPES = {
+    Date: "date",
+    Time: "time",
+    DateTime: "dateTime",
+    String: "string",
+    Number: "number",
+    Array: "array",
+};
+
+const waitUntil = (condition, checkInterval = 100) => {
+    return new Promise((resolve) => {
+        const interval = setInterval(() => {
+            if (condition())
+                return;
+            clearInterval(interval);
+            resolve(true);
+        }, checkInterval);
+    });
+};
+
+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 = undefined) {
+    if ((!isObject(data) && !isArray(data)) || !isString(path))
+        return defaultValue;
+    return get(data, path, defaultValue);
+}
+
+function dateDifference(type, firstDate, secondDate = new Date(), float = false) {
+    const first = dayjs(firstDate);
+    return first.diff(secondDate, type, float);
+}
+
+function getDateByRules(rules, date = new Date()) {
+    let result = new Date(date);
+    for (const rule of rules) {
+        result = getDate(rule.increment, rule.type, result);
+    }
+    return result;
+}
+function getDate(increment, type, date = new Date()) {
+    const result = new Date(date);
+    switch (type) {
+        case DATE_TYPES.Days: {
+            result.setDate(result.getDate() + increment);
+            return result;
+        }
+        case DATE_TYPES.Months: {
+            result.setMonth(result.getMonth() + increment);
+            return result;
+        }
+        case DATE_TYPES.Years: {
+            result.setFullYear(result.getFullYear() + increment);
+            return result;
+        }
+        case DATE_TYPES.Seconds: {
+            result.setSeconds(result.getSeconds() + increment);
+            return result;
+        }
+        case DATE_TYPES.Minutes: {
+            result.setMinutes(result.getMinutes() + increment);
+            return result;
+        }
+        case DATE_TYPES.Hours: {
+            result.setHours(result.getHours() + increment);
+            return result;
+        }
+        default:
+            return result;
+    }
+}
+
+function getToday() {
+    const startToday = new Date();
+    startToday.setHours(0, 0, 0, 0);
+    const endToday = new Date();
+    endToday.setHours(23, 59, 59, 999);
+    return { startToday, endToday };
+}
+
+function getTomorrow() {
+    const tomorrow = new Date();
+    tomorrow.setHours(0, 0, 0, 0);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    return tomorrow;
+}
+
+function getYesterday() {
+    const yesterday = new Date();
+    yesterday.setHours(0, 0, 0, 0);
+    yesterday.setDate(yesterday.getDate() - 1);
+    return yesterday;
+}
+
+dayjs.extend(todayPlugin);
+function isToday(date) {
+    try {
+        return dayjs(date).isToday();
+    }
+    catch {
+        return false;
+    }
+}
+
+dayjs.extend(tomorrowPlugin);
+function isTomorrow(date) {
+    try {
+        return dayjs(date).isTomorrow();
+    }
+    catch {
+        return false;
+    }
+}
+
+dayjs.extend(yesterdayPlugin);
+function isYesterday(date) {
+    try {
+        return dayjs(date).isYesterday();
+    }
+    catch {
+        return false;
+    }
+}
+
+function dateFormat(date, format) {
+    const correctDate = new Date(date);
+    if (!isDate(correctDate))
+        return "";
+    return dayjs(correctDate).format(format);
+}
+
+function transformToNumber(value) {
+    let result;
+    if (isString(value))
+        result = parseInt(value, 10);
+    else
+        result = Number(value);
+    return Number.isNaN(result) ? 0 : result;
+}
+
+function fieldViewFormat(field, type = "string") {
+    switch (type) {
+        case FIELD_TYPES.Array: {
+            return isArray(field) ? field.join(", ") : "";
+        }
+        case FIELD_TYPES.Date: {
+            return isString(field) || isNumber(field) || isDate(field)
+                ? dateFormat(field, "DD.MM.YYYY")
+                : "";
+        }
+        case FIELD_TYPES.DateTime: {
+            return isString(field) || isNumber(field) || isDate(field)
+                ? dateFormat(field, "DD.MM.YYYY HH:mm")
+                : "";
+        }
+        case FIELD_TYPES.Number: {
+            return isString(field) || isNumber(field) || isBoolean(field)
+                ? String(transformToNumber(field))
+                : "";
+        }
+        case FIELD_TYPES.String: {
+            return isString(field) || isNumber(field) || isBoolean(field) ? String(field) : "";
+        }
+        case FIELD_TYPES.Time: {
+            return isString(field) || isNumber(field) || isDate(field) ? dateFormat(field, "HH:mm") : "";
+        }
+        default: {
+            return isString(field) || isNumber(field) || isBoolean(field) ? String(field) : "";
+        }
+    }
+}
+
+function setByPath(data, path, value) {
+    try {
+        if (!isObject(data) && !isArray(data))
+            throw new Error("bad data");
+        set(data, path, value);
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.warn(error);
+    }
+}
+
+function jsonParse(json) {
+    if (!isString(json))
+        return null;
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+}
+
+const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function randomString(length = 10, allowCharacters = characters) {
+    let result = "";
+    let counter = 0;
+    while (counter < length) {
+        result += allowCharacters.charAt(Math.floor(Math.random() * allowCharacters.length));
+        counter += 1;
+    }
+    return result;
+}
+
+function wait(delay) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve(true);
+        }, delay);
+    });
+}
+
+function buildQueryString(params) {
+    const queryString = [];
+    for (const [key, value] of Object.entries(params)) {
+        if (isObject(value) || value == undefined)
+            continue;
+        if (isArray(value)) {
+            for (const item of value) {
+                if (item != undefined && !isObject(item))
+                    queryString.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
+            }
+        }
+        else {
+            queryString.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+        }
+    }
+    return queryString.join("&");
+}
+
+function createURLWithParams(options) {
+    const url = options.baseURL.replace(/\/$/, "").replace(/\?$/, "");
+    if (!options.params) {
+        return url;
+    }
+    const queryString = buildQueryString(options.params);
+    return `${url}?${queryString}`;
+}
+
+function trimUrl(url) {
+    return url.replace(/^\//, "").replace(/\/$/, "");
+}
+
+function arrayToMapByKey(array, key) {
+    const map = {};
+    for (const item of array) {
+        const keyValue = item[key];
+        if (isId(keyValue))
+            map[keyValue] = item;
+    }
+    return map;
+}
+
+function syncObjectValues(oldObj, newObj, exception = []) {
+    for (const field in newObj) {
+        if (exception.includes(field))
+            continue;
+        const oldValue = getByPath(oldObj, field, undefined);
+        const newValue = getByPath(newObj, field, undefined);
+        if (isUndefined(oldValue) || isUndefined(newValue))
+            continue;
+        if (oldValue === newValue)
+            continue;
+        setByPath(oldObj, field, newValue);
+    }
+}
+
+function randomNumber(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min) + min);
+}
+
+const filenameVariables = ["filename=", "filename*=UTF-8''"];
+function getFileNameFromHeader(header) {
+    const name = header
+        .split(";")
+        .find((info) => ~info.indexOf(filenameVariables[0]) || ~info.indexOf(filenameVariables[1]))
+        ?.replace(filenameVariables[0], "")
+        ?.replace(filenameVariables[1], "")
+        ?.replace(/"/g, "")
+        ?.trim();
+    return name ? decodeURI(name) : null;
+}
+
+function limitStreamOfRequests({ countRequests, maxCountInParallel, promiseGetter, refetchAfterError, resultCb, collectResult, maxTryCount = 3, }) {
+    let isStopped = false;
+    return {
+        cancel: () => {
+            isStopped = true;
+        },
+        promise: new Promise((resolve) => {
+            let currentRequests = 0;
+            let currentResponses = 0;
+            const results = [];
+            for (let i = 0; i < maxCountInParallel; i++) {
+                request(promiseGetter(++currentRequests), currentRequests);
+            }
+            function request(promise, position, tryCount = 1) {
+                if (isStopped)
+                    return void resolve(results);
+                if (currentResponses === countRequests)
+                    return void resolve(results);
+                if (position > countRequests || promise == undefined)
+                    return;
+                promise
+                    .then((result) => {
+                    if (isStopped)
+                        return void resolve(results);
+                    if (collectResult)
+                        results.push(result);
+                    if (resultCb)
+                        resultCb(result);
+                    currentResponses++;
+                    request(promiseGetter(++currentRequests), currentRequests);
+                })
+                    .catch(() => {
+                    if (isStopped)
+                        return void resolve(results);
+                    if (refetchAfterError && maxTryCount > tryCount) {
+                        void wait(1000).then(() => request(promiseGetter(position), position, tryCount + 1));
+                    }
+                    else {
+                        currentResponses++;
+                        request(promiseGetter(++currentRequests), currentRequests);
+                    }
+                });
+            }
+        }),
+    };
+}
+
+function downloadFile({ data, fileName, mimeType }) {
+    if (!IS_BROWSER && !IS_JEST)
+        return null;
+    const name = getFileNameFromHeader(fileName);
+    if (!name)
+        throw new Error("Bad filename");
+    const blob = new Blob([data], {
+        type: mimeType,
+    });
+    const downloadUrl = window.URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.style.display = "none";
+    link.download = name;
+    link.href = downloadUrl;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    link.remove();
+    window.URL.revokeObjectURL(downloadUrl);
+    return null;
+}
+
+function downloadJson(data, name) {
+    if (!IS_BROWSER && !IS_JEST)
+        return null;
+    const url = `data:text/json;charset=utf-8,${encodeURIComponent(JSON.stringify(data))}`;
+    const link = document.createElement("a");
+    link.style.display = "none";
+    link.download = name;
+    link.href = url;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    link.remove();
+}
+
+function readFile(file) {
+    return new Promise((resolve) => {
+        if (!IS_BROWSER && !IS_JEST) {
+            resolve(null);
+            return;
+        }
+        const reader = new FileReader();
+        reader.readAsText(file);
+        reader.onload = () => {
+            resolve(reader.result);
+        };
+        reader.onerror = () => {
+            resolve(null);
+        };
+    });
+}
+
+const tokenRequest = async (options) => {
+    try {
+        const response = await fetch(options.authTokenUrl, {
+            method: "GET",
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! Status: ${response.status}`);
+        }
+        const result = (await response.json());
+        const { expiresToken, token } = transformData(result, options.pathToToken, options.pathToExpires);
+        localStorage.setItem(options.storageExpiresTokenName, expiresToken);
+        localStorage.setItem(options.storageTokenName, token);
+        return token;
+    }
+    catch (error) {
+        // eslint-disable-next-line no-console
+        console.log(error);
+        window.location.replace(options.authRedirectUrl);
+        return null;
+    }
+};
+function transformData(data, pathToToken, pathToExpires) {
+    if (!isObject(data))
+        throw new Error("Bad response data");
+    const token = getByPath(data, pathToToken);
+    const expiresToken = getByPath(data, pathToExpires);
+    if ((!isString(expiresToken) && !isNumber(expiresToken)) || !isString(token))
+        throw new Error("Bad response data");
+    return {
+        expiresToken: String(expiresToken),
+        token,
+    };
+}
+
+let isFetchingAccessToken = false;
+const generateAuthMiddleWare = (options) => async (request) => {
+    if (!options.authRedirectUrl ||
+        !options.authRedirectUrl ||
+        !options.storageExpiresTokenName ||
+        !options.storageTokenName ||
+        !options.pathToExpires ||
+        !options.pathToToken) {
+        // eslint-disable-next-line no-console
+        console.error("Auth middleware hasn't required options");
+        return;
+    }
+    const isSameOrigin = !request.path.includes("http") && !request.path.includes("https");
+    if (request.token && !isSameOrigin) {
+        request.headers = {
+            ...request.headers,
+            Authorization: `Bearer ${request.token}`,
+        };
+        return;
+    }
+    if (isFetchingAccessToken)
+        await waitUntil(() => isFetchingAccessToken);
+    const expires = localStorage.getItem(options.storageExpiresTokenName);
+    let token = localStorage.getItem(options.storageTokenName);
+    if (!expires || Date.now() > +expires || !token) {
+        isFetchingAccessToken = true;
+        token = await tokenRequest(options);
+        isFetchingAccessToken = false;
+    }
+    if (!isSameOrigin)
+        request.headers = {
+            ...request.headers,
+            Authorization: `Bearer ${token}`,
+        };
+};
+
+const consoleMiddleware = (response) => {
+    return new Promise((resolve) => {
+        // eslint-disable-next-line no-console
+        console.log(response);
+        resolve(true);
+    });
+};
+
+function generateMiddlewares(activeMiddlewares, middlewareOptions) {
+    const selectedMiddlewares = [];
+    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.Logger: {
+                selectedMiddlewares.push(consoleMiddleware);
+                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);
+            })();
+        });
+    };
+}
+
+class ResponseError extends Error {
+    status;
+    description;
+    constructor({ message, status, description }) {
+        super(message);
+        this.status = status;
+        this.description = description;
+    }
+}
+function generateRequestsInstance(activeMiddlewares, middlewareOptions) {
+    const executeMiddlewares = generateMiddlewares(activeMiddlewares || [], middlewareOptions || {});
+    async function handleRequest(request, responseWithStatus) {
+        if (request.delay) {
+            await wait(request.delay);
+        }
+        if (request.mock) {
+            const transformedResult = request.transformIncomingData
+                ? request.transformIncomingData(request.mock)
+                : request.mock;
+            return responseWithStatus ? { data: transformedResult, status: 200 } : transformedResult;
+        }
+        await executeMiddlewares(request);
+        const { method, body, path, params, headers } = request;
+        const trimedPath = path.replace(/^\//, "").replace(/\/$/, "");
+        const fullPath = trimedPath.includes("http") || trimedPath.includes("https")
+            ? trimedPath
+            : `${window.location.origin}/${trimedPath}`;
+        const url = createURLWithParams({ baseURL: fullPath, params });
+        let preparedBody = body;
+        if (body && !(preparedBody instanceof FormData)) {
+            if (request.transformOutcomingData) {
+                preparedBody = request.transformOutcomingData(body);
+            }
+            if (isObject(body) || isArray(body))
+                preparedBody = JSON.stringify(preparedBody);
+        }
+        let response;
+        if (IS_BROWSER || IS_JEST) {
+            response = await fetch(url, {
+                method,
+                body: preparedBody,
+                headers: {
+                    ...(body instanceof FormData
+                        ? {}
+                        : { "Content-Type": "application/json; charset=UTF-8" }),
+                    ...headers,
+                },
+                signal: request.signal,
+            });
+        }
+        if (IS_NODE && !IS_JEST) {
+            const nodeFetch = (await import('node-fetch')).default;
+            response = await nodeFetch(url, {
+                method,
+                body: preparedBody,
+                headers: {
+                    ...(body instanceof FormData
+                        ? {}
+                        : { "Content-Type": "application/json; charset=UTF-8" }),
+                    ...headers,
+                },
+                signal: request.signal,
+            });
+        }
+        if (!response) {
+            throw new Error("hasn't response");
+        }
+        if (!response.ok) {
+            throw new ResponseError({
+                status: response.status,
+                message: `HTTP error! Status: ${response.status}`,
+            });
+        }
+        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,
+                    fileName,
+                    mimeType,
+                });
+            return responseWithStatus
+                ? {
+                    data: data,
+                    status: response.status,
+                }
+                : data;
+        }
+        if (request.withoutResponse)
+            return responseWithStatus ? { data: true, status: response.status } : true;
+        const result = (await response.json());
+        const transformedResult = request.transformIncomingData
+            ? request.transformIncomingData(result)
+            : result;
+        return responseWithStatus
+            ? { data: transformedResult, status: response.status }
+            : transformedResult;
+    }
+    async function requestApi(request) {
+        return handleRequest(request, false);
+    }
+    async function requestApiWithStatus(request) {
+        return handleRequest(request, true);
+    }
+    return {
+        requestApi,
+        requestApiWithStatus,
+    };
+}
+
+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;
+}
+
+exports.API_MIDDLEWARES = API_MIDDLEWARES;
+exports.COLOR_FORMATS = COLOR_FORMATS;
+exports.DATE_TYPES = DATE_TYPES;
+exports.FIELD_TYPES = FIELD_TYPES;
+exports.IS_BROWSER = IS_BROWSER;
+exports.IS_BUN = IS_BUN;
+exports.IS_DENO = IS_DENO;
+exports.IS_JEST = IS_JEST;
+exports.IS_NODE = IS_NODE;
+exports.IS_WEB_WORKER = IS_WEB_WORKER;
+exports.ResponseError = ResponseError;
+exports.arrayToMapByKey = arrayToMapByKey;
+exports.buildQueryString = buildQueryString;
+exports.checkType = checkType;
+exports.createURLWithParams = createURLWithParams;
+exports.dateDifference = dateDifference;
+exports.dateFormat = dateFormat;
+exports.downloadFile = downloadFile;
+exports.downloadJson = downloadJson;
+exports.fieldViewFormat = fieldViewFormat;
+exports.generateRequestsInstance = generateRequestsInstance;
+exports.getByPath = getByPath;
+exports.getColorFormat = getColorFormat;
+exports.getDateByRules = getDateByRules;
+exports.getFileNameFromHeader = getFileNameFromHeader;
+exports.getToday = getToday;
+exports.getTomorrow = getTomorrow;
+exports.getYesterday = getYesterday;
+exports.isArray = isArray;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isId = isId;
+exports.isNull = isNull;
+exports.isNullable = isNullable;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.isToday = isToday;
+exports.isTomorrow = isTomorrow;
+exports.isUndefined = isUndefined;
+exports.isYesterday = isYesterday;
+exports.jsonParse = jsonParse;
+exports.limitStreamOfRequests = limitStreamOfRequests;
+exports.randomNumber = randomNumber;
+exports.randomString = randomString;
+exports.readFile = readFile;
+exports.setByPath = setByPath;
+exports.syncObjectValues = syncObjectValues;
+exports.takeOpacityColors = takeOpacityColors;
+exports.transformHEXtoRGB = transformHEXtoRGB;
+exports.transformRGBAtoRGB = transformRGBAtoRGB;
+exports.transformRGBtoRGBA = transformRGBtoRGBA;
+exports.transformToColor = transformToColor;
+exports.transformToNumber = transformToNumber;
+exports.trimUrl = trimUrl;
+exports.wait = wait;
+exports.waitUntil = waitUntil;
+//# sourceMappingURL=index.cjs.map