@rabbitio/ui-kit 1.0.0-beta.9 → 1.0.0-beta.91

package/src/common-apis/utils/cache.js

@@ -0,0 +1,242 @@
+import { improveAndRethrow } from "./errorUtils.js";
+import { Logger } from "./logging/logger.js";
+
+/**
+ * TODO: [tests, critical] Ued by payments logic
+ *
+ * Simple cache based on Map.
+ * Provides ability to store event-dependent data.
+ */
+export class Cache {
+    /**
+     * @param [eventBus=null] {EventBus} EventBus.js lib instance if you plan to use Cache with events handling
+     * @param [noSessionEvents=[]] {string[]} array of events that will be treated as "no session", you should pass EventBus to make it work
+     */
+    constructor(eventBus = null, noSessionEvents = []) {
+        this._cache = new Map();
+        this._eventDependentDataKeys = [];
+        this._noSessionEvents = noSessionEvents;
+        this._eventBus = eventBus;
+    }
+
+    _setupIntervalClearingExpired() {
+        let cleaner = function () {
+            try {
+                for (const key of this._cache.keys()) {
+                    const item = this._cache.get(key);
+                    if (item && item.ttlMs && item.addedMsTimestamp + item.ttlMs < Date.now()) {
+                        this._cache.delete(key);
+                    }
+                }
+            } catch (e) {
+                improveAndRethrow(e, "_intervalClearingExpiredCache");
+            }
+        };
+
+        cleaner = cleaner.bind(this);
+
+        setInterval(cleaner, 1000);
+    }
+
+    /**
+     * Puts data to cache
+     *
+     * @param key {string} string key for this data
+     * @param data {any} any data
+     * @param ttlMs {number|null} optional milliseconds number for cache lifetime
+     * @throws {Error} when the data is null/undefined because these values for data are reserved for internal logic
+     */
+    put(key, data, ttlMs = null) {
+        try {
+            if (typeof key !== "string" || data == null) {
+                throw new Error(`Trying to cache corrupted data: ${key}, ${data}`);
+            }
+            this._cache.set(key, {
+                data: data,
+                addedMsTimestamp: Date.now(),
+                ttlMs: ttlMs,
+            });
+        } catch (e) {
+            improveAndRethrow(e, "cache.put");
+        }
+    }
+
+    putSessionDependentData(key, data, ttlMs = null) {
+        this._putEventDependentData(key, data, this._noSessionEvents, ttlMs);
+    }
+
+    /**
+     * Puts data to cache and adds its key to list of keys that should be related by each of given events.
+     *
+     * @param key {string} key for cache
+     * @param data {any} any caching data
+     * @param events {string[]} list of events forcing putting data to be removed when triggered
+     * @param ttlMs {|null} optional time to live for this cache item
+     * @throws {Error} when the data is null/undefined because these values for data are reserved for internal logic
+     */
+    putEventDependentData(key, data, events, ttlMs = null) {
+        this._putEventDependentData(key, data, events, ttlMs);
+    }
+
+    _putEventDependentData(key, data, events, ttlMs = null) {
+        try {
+            if (typeof key !== "string" || data == null) {
+                throw new Error(`Trying to cache corrupted data: ${key}, ${data}`);
+            }
+            this._cache.set(key, {
+                data: data,
+                addedMsTimestamp: Date.now(),
+                ttlMs: ttlMs,
+            });
+            for (let event of events) {
+                const eventAndKeys = this._eventDependentDataKeys.find(item => item[0] === event);
+                if (eventAndKeys) {
+                    eventAndKeys.push(key);
+                } else if (this._eventBus) {
+                    this._eventDependentDataKeys.push([event, key]);
+                    this._eventBus.addEventListener(event, () => {
+                        try {
+                            const keys = this._eventDependentDataKeys.find(item => item[0] === event);
+                            (keys ?? [event]).slice(1).forEach(key => this._cache.delete(key));
+                        } catch (e) {
+                            Logger.logError(e, "cache.removing-for-event", `Event: ${event}`);
+                        }
+                    });
+                }
+            }
+        } catch (e) {
+            improveAndRethrow(e, "cache.putEventDependentData");
+        }
+    }
+
+    // TODO: [feature, low] add clearing of expired data by schedule
+    get(key) {
+        try {
+            const item = this._cache.get(key);
+            if (item) {
+                if (item.addedMsTimestamp && item.ttlMs !== null && item.addedMsTimestamp + item.ttlMs < Date.now()) {
+                    this._cache.delete(key);
+                    return null;
+                } else {
+                    return item.data;
+                }
+            }
+
+            return null;
+        } catch (e) {
+            improveAndRethrow(e, "cache.get");
+        }
+    }
+
+    getLastUpdateTimestamp(key) {
+        return this._cache.get(key)?.addedMsTimestamp ?? null;
+    }
+
+    /**
+     * Updates the timestamp of the last update for specified key to the provided value.
+     * Can be useful when TTL is controlled outside this class.
+     *
+     * @param key {string}
+     * @param timestamp {number}
+     * @return {boolean}
+     */
+    setLastUpdateTimestamp(key, timestamp) {
+        try {
+            const item = this._cache.get(key);
+            if (item != null && typeof timestamp === "number") {
+                this._cache.set(key, { ...item, addedTimestampMs: timestamp });
+                return true;
+            }
+            return false;
+        } catch (e) {
+            improveAndRethrow("cache.setLastUpdateTimestamp");
+        }
+    }
+
+    invalidate(key) {
+        try {
+            this._cache.delete(key);
+        } catch (e) {
+            improveAndRethrow(e, "cache.invalidate");
+        }
+    }
+
+    invalidateContaining(keyPart) {
+        if (typeof keyPart !== "string" || keyPart === "") {
+            throw new Error("Trying to invalidate containing wrong key or empty key: " + keyPart);
+        }
+
+        try {
+            const matchedKeys = Array.from(this._cache.keys()).filter(
+                key => typeof key === "string" && new RegExp(keyPart).test(key)
+            );
+            for (let i = 0; i < matchedKeys.length; ++i) {
+                this._cache.delete(matchedKeys[i]);
+            }
+        } catch (e) {
+            improveAndRethrow(e, "invalidateContaining");
+        }
+    }
+
+    clear() {
+        this._cache.clear();
+        this._sessionDependentDataKeys = [];
+    }
+
+    /**
+     * Saves given data string to persistent cache.
+     * NOTE: we have no TTL here, implement if needed.
+     *
+     * WARNING: use only when really needed and don't store big data as we use localStorage
+     * under the hood and its capacity is restricted.
+     *
+     * @param uniqueKey {string} the key should be unique
+     * @param data {string} only string data allowed
+     */
+    putClientPersistentData(uniqueKey, data) {
+        try {
+            if (typeof window !== "undefined") {
+                localStorage.setItem(uniqueKey, data);
+            }
+        } catch (e) {
+            improveAndRethrow(e, "cache.putClientPersistentData");
+        }
+    }
+
+    /**
+     * @param uniqueKey {string}
+     * @return {string|null}
+     */
+    getClientPersistentData(uniqueKey) {
+        try {
+            if (typeof window !== "undefined") {
+                return localStorage.getItem(uniqueKey);
+            }
+            return null;
+        } catch (e) {
+            improveAndRethrow(e, "cache.getClientPersistentData");
+        }
+    }
+
+    /**
+     * Only makes effect if the TTL is not null.
+     *
+     * @param key {string}
+     * @param ttlMs {number|null}
+     */
+    markCacheItemAsExpiredButDontRemove(key, ttlMs = null) {
+        try {
+            const item = this._cache.get(key);
+            const ttlFinalMs = ttlMs ?? item?.ttlMs;
+            if (item != null && ttlFinalMs) {
+                this._cache.set(key, {
+                    data: item.data,
+                    addedMsTimestamp: Date.now() - ttlFinalMs - 1,
+                    ttlMs: ttlFinalMs,
+                });
+            }
+        } catch (e) {
+            improveAndRethrow(e, "cache.markCacheItemAsExpiredButDontRemove");
+        }
+    }
+}

package/src/{common → common-apis/utils}/errorUtils.js

@@ -1,3 +1,6 @@
+import { Logger } from "./logging/logger.js";
+import { safeStringify } from "./safeStringify.js";
+
 /**
  * This function improves the passed error object (its message) by adding the passed function name
  * and additional message to it.
@@ -25,3 +28,15 @@ function improvedErrorMessage(e, settingFunction, additionalMessage) {
 
     return message;
 }
+
+export function logErrorOrOutputToConsole(e) {
+    try {
+        // TODO: [dev] remove this after few weeks of testing output in real life
+        // eslint-disable-next-line no-console
+        console.log("BEFORE SAFE", e);
+        Logger.log("logErrorOrOutputToConsole", safeStringify(e));
+    } catch (e) {
+        // eslint-disable-next-line no-console
+        console.log("logErrorOrOutputToConsole", e);
+    }
+}

package/src/common-apis/utils/logging/logger.js

@@ -0,0 +1,41 @@
+import { LogsStorage } from "./logsStorage.js";
+import { safeStringify } from "../safeStringify.js";
+
+export class Logger {
+    /**
+     * Logs to client logs storage.
+     *
+     * WARNING! this method should ce used carefully for critical logging as we have the restriction for storing logs
+     *          on client side as we store them inside the local storage. Please see details inside storage.js
+     * @param logString {string} log string
+     * @param source {string} source of the log entry
+     */
+    static log(logString, source) {
+        const timestamp = new Date().toISOString();
+        LogsStorage.saveLog(`${timestamp}|${source}:${logString}`);
+    }
+
+    static logError(e, settingFunction, additionalMessage = "", onlyToConsole = false) {
+        let message = `\nFunction call ${settingFunction ?? ""} failed. Error message: ${
+            e?.message
+        }. ${additionalMessage} `;
+        message +=
+            `${e?.errorDescription ?? ""}${e?.howToFix ?? ""}` +
+            (e?.httpStatus === 403 ? "Authentication has expired or was lost. " : "");
+
+        if (e?.response) {
+            try {
+                const responseData = safeStringify({ response: e.response });
+                responseData && (message += `\n${responseData}. `);
+            } catch (e) {}
+        }
+
+        const finalErrorText = message + ". " + safeStringify(e);
+        // eslint-disable-next-line no-console
+        console.error(finalErrorText, e);
+
+        if (!onlyToConsole) {
+            this.log(finalErrorText, "logError");
+        }
+    }
+}

package/src/common-apis/utils/logging/logsStorage.js

@@ -0,0 +1,61 @@
+export class LogsStorage {
+    static _inMemoryStorage = [];
+    static _logsStorageId = "clietnLogs_j203fj2D0n-d1";
+
+    static saveLog(log) {
+        this._inMemoryStorage.push(log);
+    }
+
+    static getInMemoryLogs() {
+        return this._inMemoryStorage;
+    }
+
+    static getAllLogs() {
+        let storedLogs = "";
+        if (typeof window !== "undefined") {
+            storedLogs = localStorage.getItem(this._logsStorageId);
+        }
+        return `${storedLogs}\n${this._inMemoryStorage.join("\n")}`;
+    }
+
+    /**
+     * @param logger {Logger}
+     */
+    static saveToTheDisk(logger) {
+        try {
+            const MAX_LOCAL_STORAGE_VOLUME_BYTES = 5 * 1024 * 1024;
+            const MAX_LOGS_STORAGE_BYTES = MAX_LOCAL_STORAGE_VOLUME_BYTES * 0.65;
+            if (typeof window !== "undefined") {
+                const existingLogs = localStorage.getItem(this._logsStorageId);
+                const logsString = `${existingLogs}\n${this._inMemoryStorage.join("\n")}`;
+                const lettersCountToRemove = logsString.length - Math.round(MAX_LOGS_STORAGE_BYTES / 2);
+                if (lettersCountToRemove > 0) {
+                    localStorage.setItem(
+                        this._logsStorageId,
+                        logsString.slice(lettersCountToRemove, logsString.length)
+                    );
+                } else {
+                    localStorage.setItem(this._logsStorageId, logsString);
+                }
+                this._inMemoryStorage = [];
+            }
+        } catch (e) {
+            logger?.logError(e, "saveToTheDisk", "Failed to save logs to disk");
+        }
+    }
+
+    static removeAllClientLogs() {
+        if (typeof window !== "undefined") {
+            if (localStorage.getItem("doNotRemoveClientLogsWhenSignedOut") !== "true") {
+                localStorage.removeItem(this._logsStorageId);
+            }
+        }
+        this._inMemoryStorage = [];
+    }
+
+    static setDoNotRemoveClientLogsWhenSignedOut(value) {
+        if (typeof window !== "undefined") {
+            localStorage.setItem("doNotRemoveClientLogsWhenSignedOut", value);
+        }
+    }
+}

package/src/common-apis/utils/postponeExecution.js

@@ -0,0 +1,11 @@
+export function postponeExecution(execution, timeoutMS = 1000) {
+    return new Promise((resolve, reject) => {
+        setTimeout(async () => {
+            try {
+                resolve(await execution());
+            } catch (e) {
+                reject(e);
+            }
+        }, timeoutMS);
+    });
+}

package/src/common-apis/utils/rabbitTicker.js

@@ -0,0 +1,24 @@
+/**
+ * Major point of rabbit ticker format definition.
+ * Our asset ticker format is just stick standard (printable) ticker with protocol code.
+ * If protocol code is the same as asset ticker than it is not added.
+ * Examples:
+ * SHIBERC20 - shiba inu on ethereum,
+ * TON - Ton coin on ton blockchain,
+ * BTC - Bitcoin in BTC mainnet,
+ * NOTTON - Notcoin in Ton blockchain
+ *
+ * @param standardPrintableTicker {string}
+ * @param protocolOrNetworkCode {string}
+ * @return {string}
+ */
+export function toRabbitTicker(standardPrintableTicker, protocolOrNetworkCode) {
+    if (
+        typeof standardPrintableTicker !== "string" ||
+        (typeof protocolOrNetworkCode !== "string" && protocolOrNetworkCode != null)
+    )
+        throw new Error("Wrong ticker/protocol passed: " + standardPrintableTicker + ", " + protocolOrNetworkCode);
+    const upperTicker = standardPrintableTicker.toUpperCase();
+    const upperCode = (protocolOrNetworkCode ?? "").toUpperCase();
+    return `${upperTicker}${upperCode === upperTicker ? "" : upperCode}`;
+}

package/src/common-apis/utils/safeStringify.js

@@ -0,0 +1,50 @@
+/**
+ * Stringify given object by use of JSON.stringify but handles circular structures and "response", "request" properties
+ * to avoid stringing redundant data when printing errors containing request/response objects.
+ *
+ * @param object - object to be stringed
+ * @param indent - custom indentation
+ * @return {string} - stringed object
+ */
+export function safeStringify(object, indent = 2) {
+    let cache = [];
+    if (
+        typeof object === "string" ||
+        typeof object === "function" ||
+        typeof object === "number" ||
+        typeof object === "undefined" ||
+        typeof object === "boolean"
+    ) {
+        return String(object);
+    }
+    const retVal = JSON.stringify(
+        object,
+        (key, value) => {
+            if (key.toLowerCase().includes("request")) {
+                return JSON.stringify({
+                    body: value?.body,
+                    query: value?.query,
+                    headers: value?.headers,
+                });
+            }
+
+            if (key.toLowerCase().includes("response")) {
+                return JSON.stringify({
+                    statusText: value?.statusText,
+                    status: value?.status,
+                    data: value?.data,
+                    headers: value?.headers,
+                });
+            }
+
+            return typeof value === "object" && value !== null
+                ? cache.includes(value)
+                    ? "duplicated reference" // Duplicated references were found, discarding this key
+                    : cache.push(value) && value // Store value in our collection
+                : value;
+        },
+        indent
+    );
+    cache = null;
+    return retVal;
+}

package/src/index.js

@@ -1,10 +1,97 @@
 // UI-KIT components
-export { Button } from "./components/atoms/buttons/Button/Button.jsx";
-export { LoadingDots } from "./components/atoms/LoadingDots/LoadingDots.jsx";
-export { SupportChat } from "./components/atoms/SupportChat/SupportChat.jsx";
-export { AssetIcon } from "./components/atoms/AssetIcon/AssetIcon.jsx";
-
-// Common code
-export { improveAndRethrow } from "./common/errorUtils.js";
-export { FiatCurrenciesService } from "./common/fiatCurrenciesService.js";
-export { AmountUtils } from "./common/amountUtils.js";
+export { Button } from "./ui-kit/components/atoms/buttons/Button/Button.jsx";
+export { LoadingDots } from "./ui-kit/components/atoms/LoadingDots/LoadingDots.jsx";
+export { SupportChat } from "./ui-kit/components/atoms/SupportChat/SupportChat.jsx";
+export { AssetIcon } from "./ui-kit/components/atoms/AssetIcon/AssetIcon.jsx";
+export { LinkButton, ICON_ROTATE_OPTIONS } from "./ui-kit/components/atoms/buttons/LinkButton/LinkButton.jsx";
+export { DialogButtons } from "./ui-kit/components/organisms/Dialog/DialogButtons/DialogButtons.jsx";
+export { BackgroundTitle } from "./ui-kit/components/atoms/BackgroundTitle/BackgroundTitle.jsx";
+export { Close, CLOSE_COLORS } from "./ui-kit/components/atoms/buttons/Close/Close.jsx";
+export { Validation } from "./ui-kit/components/atoms/Validation/Validation.jsx";
+export { Dialog, DIALOG_SIZES, DIALOG_TRANSITION_STEP_DURATION } from "./ui-kit/components/organisms/Dialog/Dialog.jsx";
+export { DialogStep, DIALOG_STEP_CLASS } from "./ui-kit/components/organisms/Dialog/DialogStep/DialogStep.jsx";
+export { AssetSelection } from "./ui-kit/components/atoms/AssetSelection/AssetSelection.jsx";
+export { Tooltip, TOOLTIP_POSITIONS } from "./ui-kit/components/atoms/Tooltip/Tooltip.jsx";
+export { NoticeIcon } from "./ui-kit/components/atoms/NoticeIcon/NoticeIcon.jsx";
+export { TitleBox } from "./ui-kit/components/atoms/TitleBox/TitleBox.jsx";
+export { AmountInput } from "./ui-kit/components/molecules/AmountInput/AmountInput.jsx";
+export { SwapForm } from "./ui-kit/components/organisms/SwapForm/SwapForm.jsx";
+export { Textarea } from "./ui-kit/components/atoms/Textarea/Textarea.jsx";
+export { QrCode } from "./ui-kit/components/atoms/QrCode/QrCode.jsx";
+export { LinesOfText } from "./ui-kit/components/atoms/TwoLinesOfText/LinesOfText.jsx";
+export { LineWithIconLink } from "./ui-kit/components/molecules/LineWithIconLink/LineWithIconLink.jsx";
+export { DeterminedErrorDialogStep } from "./ui-kit/components/templates/DeterminedErrorDialogStep/DeterminedErrorDialogStep.jsx";
+export { TitledLineWithIconLink } from "./ui-kit/components/molecules/TitledLineWithIconLink/TitledLineWithIconLink.jsx";
+export { RadioButtonWithText } from "./ui-kit/components/atoms/buttons/RadioButtonWithText/RadioButtonWithText.jsx";
+export { InformationMessage } from "./ui-kit/components/atoms/InformationMessage/InformationMessage.jsx";
+export { Input } from "./ui-kit/components/atoms/Input/Input.jsx";
+export { COIN_PICKER_MODES, CoinPicker } from "./ui-kit/components/molecules/CoinPicker/CoinPicker.jsx";
+export { CoinPickerDialogStep } from "./ui-kit/components/organisms/CoinPickerDialogStep/CoinPickerDialogStep.jsx";
+export { SearchableCoinsList } from "./ui-kit/components/molecules/SearchableCoinsList/SearchableCoinsList.jsx";
+export { ColoredNotice } from "./ui-kit/components/molecules/ColoredNotice/ColoredNotice.jsx";
+export { WaitlistSubscription } from "./ui-kit/components/organisms/WaitlistSubscription/WaitlistSubscription.jsx";
+export { LogoCarousel } from "./ui-kit/components/molecules/LogoCarousel/LogoCarousel.jsx";
+
+// UI-KIT constants
+export { FALLBACK_ASSET_ICON_URL, DEFAULT_CRYPTO_DECIMAL_COUNT } from "./common-apis/globalConstants.jsx";
+
+export { useCallHandlingErrors } from "./ui-kit/hooks/useCallHandlingErrors.js";
+export { useReferredState } from "./ui-kit/hooks/useReferredState.js";
+export { handleClickOutside } from "./ui-kit/utils/uiUtils.js";
+export { InputValuesProviders } from "./ui-kit/utils/inputValueProviders.js";
+export { copyBrowserTextToClipboard } from "./ui-kit/utils/textUtils.js";
+export { useIsHydrated } from "./ui-kit/hooks/useIsHydrated.js";
+
+export { saveQueryParameterAndValues } from "./ui-kit/utils/urlQueryUtils.js";
+export { removeQueryParameterAndValues } from "./ui-kit/utils/urlQueryUtils.js";
+export { getQueryParameterSingleValue } from "./ui-kit/utils/urlQueryUtils.js";
+export { getQueryParameterValues } from "./ui-kit/utils/urlQueryUtils.js";
+
+// Common code lib (to be extracted later to dedicated lib)
+export { improveAndRethrow } from "./common-apis/utils/errorUtils.js";
+export { logErrorOrOutputToConsole } from "./common-apis/utils/errorUtils.js";
+export { FiatCurrenciesService } from "./common-apis/services/fiatCurrenciesService.js";
+export { AmountUtils } from "./common-apis/utils/amountUtils.js";
+export { toRabbitTicker } from "./common-apis/utils/rabbitTicker.js";
+
+export { Blockchain } from "./common-apis/models/blockchain.js";
+export { Protocol } from "./common-apis/models/protocol.js";
+export { Coin } from "./common-apis/models/coin.js";
+
+export { Cache } from "./common-apis/utils/cache.js";
+export { safeStringify } from "./common-apis/utils/safeStringify.js";
+export { LogsStorage } from "./common-apis/utils/logging/logsStorage.js";
+export { Logger } from "./common-apis/utils/logging/logger.js";
+export { postponeExecution } from "./common-apis/utils/postponeExecution.js";
+export { AxiosAdapter } from "./common-apis/adapters/axiosAdapter.js";
+
+export { EmailsApi } from "./common-apis/external-apis/emailAPI.js";
+export { IpAddressProvider } from "./common-apis/external-apis/ipAddressProviders.js";
+
+export { GoogleAnalyticsAdapter } from "./common-apis/adapters/analyticsAdapters/googleAnalyticsAdapter.js";
+export { MixpanelAdapter } from "./common-apis/adapters/analyticsAdapters/mixpanelAdapter.js";
+export { MetrikaAdapter } from "./common-apis/adapters/analyticsAdapters/metrikaAdapter.js";
+
+// Robust data retriever service and related APIs (to be extracted later to dedicated lib)
+export { CacheAndConcurrentRequestsResolver } from "./robust-api-caller/cacheAndConcurrentRequestsResolver.js";
+export { CachedRobustExternalApiCallerService } from "./robust-api-caller/cachedRobustExternalApiCallerService.js";
+export { CancelProcessing } from "./robust-api-caller/cancelProcessing.js";
+export { ExternalApiProvider } from "./robust-api-caller/externalApiProvider.js";
+export { RobustExternalAPICallerService } from "./robust-api-caller/robustExternalAPICallerService.js";
+export { ConcurrentCalculationsMetadataHolder } from "./robust-api-caller/concurrentCalculationsMetadataHolder.js";
+
+export { ApiGroups } from "./common-apis/external-apis/apiGroups.js";
+export { ApiGroup } from "./common-apis/external-apis/apiGroups.js";
+
+// Swaps lib (to be extracted later to dedicated lib)
+export { ExistingSwap } from "./swaps-lib/models/existingSwap.js";
+export { ExistingSwapWithFiatData } from "./swaps-lib/models/existingSwapWithFiatData.js";
+export { BaseSwapCreationInfo } from "./swaps-lib/models/baseSwapCreationInfo.js";
+export { SwapProviderCoinInfo } from "./swaps-lib/models/swapProviderCoinInfo.js";
+export { SwapProvider } from "./swaps-lib/external-apis/swapProvider.js";
+export { SwapspaceSwapProvider } from "./swaps-lib/external-apis/swapspaceSwapProvider.js";
+export { LetsExchangeSwapProvider } from "./swaps-lib/external-apis/letsExchangeSwapProvider.js";
+export { ExolixSwapProvider } from "./swaps-lib/external-apis/exolixSwapProvider.js";
+export { SwapUtils } from "./swaps-lib/utils/swapUtils.js";
+export { PublicSwapService } from "./swaps-lib/services/publicSwapService.js";
+export { Partner, KYC_LEVELS } from "./swaps-lib/models/partner.js";