@rabbitio/ui-kit 1.0.0-beta.41 → 1.0.0-beta.43

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rabbitio/ui-kit",
-    "version": "1.0.0-beta.41",
+    "version": "1.0.0-beta.43",
     "description": "Rabbit.io react.js components kit",
     "type": "module",
     "main": "./dist/index.cjs",
@@ -15,10 +15,13 @@
         "./index.css": "./dist/index.css"
     },
     "scripts": {
+        "prepare": "husky",
         "build": "rm -rf dist && microbundle --no-compress --jsx React.createElement --jsxFragment React.Fragment --jsxImportSource react --globals react/jsx-runtime=jsx --visualize",
         "prepublish": "npm run build",
         "storybook": "storybook dev -p 6006",
-        "build-storybook": "storybook build"
+        "build-storybook": "storybook build",
+        "test-watching": "vitest",
+        "test": "vitest run --coverage"
     },
     "keywords": [
         "rabbit.io",
@@ -59,14 +62,19 @@
         "@storybook/react": "^7.6.6",
         "@storybook/react-webpack5": "^7.6.6",
         "@storybook/test": "^7.6.6",
+        "@vitest/coverage-v8": "^1.5.0",
+        "husky": "^9.0.11",
         "microbundle": "^0.15.1",
         "prettier": "^3.1.1",
         "prop-types": "^15.8.1",
         "resolve-url-loader": "^5.0.0",
         "sass": "^1.70.0",
         "sass-loader": "^14.1.0",
+        "should": "13.2.3",
+        "sinon": "17.0.1",
         "storybook": "^7.6.6",
-        "style-loader": "^3.3.3"
+        "style-loader": "^3.3.3",
+        "vitest": "1.5.0"
     },
     "prettier": {
         "trailingComma": "es5",

package/src/common/amountUtils.js

@@ -273,11 +273,13 @@ export class AmountUtils {
     }
 
     /**
+     * Returns integer part of number as a string.
+     *
      * @param amount {BigNumber|number|string|null|undefined} The number value to be trimmed.
      *                                                        HEX strings also allowed "0x..." and JS hex numbers
      * @return {string|null}
      */
-    static intStr(amount) {
+    static toIntegerString(amount) {
         return this.trim(amount, 0);
     }
 
@@ -392,7 +394,7 @@ export class AmountUtils {
                     leftNumber = leftNumber.times(multiplier);
                 }
             }
-            const leftAmountString = AmountUtils.intStr(leftNumber);
+            const leftAmountString = AmountUtils.toIntegerString(leftNumber);
             const rightAmountString =
                 right != null
                     ? right.toFixed(

package/src/common/external-apis/ipAddressProviders.js

@@ -0,0 +1,138 @@
+import EventBusInstance from "eventbusjs";
+import { ExternalApiProvider } from "../../robustExteranlApiCallerService/externalApiProvider.js";
+import { ApiGroups } from "./apiGroups.js";
+import { CachedRobustExternalApiCallerService } from "../../robustExteranlApiCallerService/cachedRobustExternalApiCallerService.js";
+import { Cache } from "../utils/cache.js";
+import { improveAndRethrow } from "../errorUtils.js";
+
+class BigdatacloudIpAddressProvider extends ExternalApiProvider {
+    constructor() {
+        super(
+            "https://api.bigdatacloud.net/data/client-ip",
+            "get",
+            15000,
+            ApiGroups.BIGDATACLOUD
+        );
+    }
+
+    getDataByResponse(
+        response,
+        params = [],
+        subRequestIndex = 0,
+        iterationsData = []
+    ) {
+        return response?.data && response.data?.ipString;
+    }
+}
+
+class TrackipIpAddressProvider extends ExternalApiProvider {
+    constructor() {
+        super("https://www.trackip.net/ip", "get", 15000, ApiGroups.TRACKIP);
+    }
+
+    getDataByResponse(
+        response,
+        params = [],
+        subRequestIndex = 0,
+        iterationsData = []
+    ) {
+        return response?.data;
+    }
+}
+
+class IpifyV6IpAddressProvider extends ExternalApiProvider {
+    constructor() {
+        super(
+            "https://api6.ipify.org/?format=json",
+            "get",
+            15000,
+            ApiGroups.IPIFY
+        );
+    }
+
+    getDataByResponse(
+        response,
+        params = [],
+        subRequestIndex = 0,
+        iterationsData = []
+    ) {
+        return response?.data && response.data?.ip;
+    }
+}
+
+class IpifyIpAddressProvider extends ExternalApiProvider {
+    constructor() {
+        super(
+            "https://api.ipify.org/?format=json",
+            "get",
+            15000,
+            ApiGroups.IPIFY
+        );
+    }
+
+    getDataByResponse(
+        response,
+        params = [],
+        subRequestIndex = 0,
+        iterationsData = []
+    ) {
+        return response?.data && response.data?.ip;
+    }
+}
+
+class WhatismyipaddressIpAddressProvider extends ExternalApiProvider {
+    constructor() {
+        super(
+            "http://bot.whatismyipaddress.com/",
+            "get",
+            15000,
+            ApiGroups.WHATISMYIPADDRESS
+        );
+    }
+
+    getDataByResponse(
+        response,
+        params = [],
+        subRequestIndex = 0,
+        iterationsData = []
+    ) {
+        return response?.data;
+    }
+}
+
+export class IpAddressProvider {
+    static externalIPAddressAPICaller =
+        new CachedRobustExternalApiCallerService(
+            "externalIPAddressAPICaller",
+            new Cache(EventBusInstance),
+            [
+                new BigdatacloudIpAddressProvider(),
+                new TrackipIpAddressProvider(),
+                new IpifyV6IpAddressProvider(),
+                new IpifyIpAddressProvider(),
+                new WhatismyipaddressIpAddressProvider(),
+            ],
+            300_000
+        );
+
+    /**
+     * Returns current public IP address identified by one of external services.
+     *
+     * It is easier than manual identification and also (as ip needed for server side to check it) it saves us from
+     * issues related to changes of infrastructure configurations (like adding proxies etc.) so we should not configure
+     * anything on server side to get correct client's IP.
+     *
+     * @returns {Promise<String>} IP address
+     * @throws {Error} if fails to retrieve IP address from all the services
+     */
+    static async getClientIpAddress() {
+        try {
+            return await this.externalIPAddressAPICaller.callExternalAPICached(
+                [],
+                7000
+            );
+        } catch (e) {
+            improveAndRethrow(e, "getClientIpAddress");
+        }
+    }
+}

package/src/common/tests/integration/external-apis/ipAddressProviders/getClientIpAddress.test.js

@@ -0,0 +1,14 @@
+import should from "should";
+
+import { describe, it } from "vitest";
+import { IpAddressProvider } from "../../../../external-apis/ipAddressProviders.js";
+
+describe("ipAddressProviders", function () {
+    describe("#getClientIpAddress", function () {
+        it("Should successfully retrieve IP address", async function () {
+            (
+                await IpAddressProvider.getClientIpAddress()
+            ).should.not.be.empty();
+        });
+    });
+});

package/src/common/utils/cache.js

@@ -9,10 +9,10 @@ import { Logger } from "./logging/logger.js";
  */
 export class Cache {
     /**
-     * @param eventBus {EventBus} EventBus.js lib instance
-     * @param [noSessionEvents=[]] {string[]} array of events that will be treated as "no session"
+     * @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, noSessionEvents = []) {
+    constructor(eventBus = null, noSessionEvents = []) {
         this._cache = new Map();
         this._eventDependentDataKeys = [];
         this._noSessionEvents = noSessionEvents;
@@ -102,7 +102,7 @@ export class Cache {
                 );
                 if (eventAndKeys) {
                     eventAndKeys.push(key);
-                } else {
+                } else if (this._eventBus) {
                     this._eventDependentDataKeys.push([event, key]);
                     this._eventBus.addEventListener(event, () => {
                         try {

package/src/components/tests/utils/inputValueProviders/provideFormatOfFloatValueByInputString.test.js

@@ -0,0 +1,139 @@
+import should from "should";
+
+import { describe, it } from "vitest";
+import { InputValuesProviders } from "../../../utils/inputValueProviders.js";
+
+describe("InputValueProviders", function () {
+    describe("#provideFormatOfFloatValueByInputString", function () {
+        [
+            {
+                max: null,
+                maxSuffix: 2,
+                test: "1989401950928592501985.3233",
+                expected: "1989401950928592501985.32",
+                message: "Should not touch prefix if max is null",
+            },
+            {
+                max: 21000000,
+                maxSuffix: 2,
+                test: "1989401950928592501985.3243",
+                expected: "92501985.32",
+                message:
+                    "Should left no more than max digits count for prefix - some prefix case",
+            },
+            {
+                max: 3,
+                maxSuffix: 2,
+                test: "1989401950928592501985.3243",
+                expected: "5.32",
+                message:
+                    "Should left no more than max digits count for prefix - min prefix case",
+            },
+            {
+                max: 21000000,
+                maxSuffix: 1,
+                test: "232.1243",
+                expected: "232.1",
+                message:
+                    "Should left no more than maxSuffix digits count in suffix - case maxSuffix is minimal = 1 and actual is londer",
+            },
+            {
+                max: 21000000,
+                maxSuffix: 1,
+                test: "232.1",
+                expected: "232.1",
+                message:
+                    "Should left no more than maxSuffix digits count in suffix - case maxSuffix is minimal = 1 and actual is the same length",
+            },
+            {
+                max: 21000000,
+                maxSuffix: 8,
+                test: "232.1243909909",
+                expected: "232.12439099",
+                message:
+                    "Should left no more than maxSuffix digits count in suffix - some maxSuffix case and actual suffix longer",
+            },
+            {
+                max: 21000000,
+                maxSuffix: 8,
+                test: "232.1243",
+                expected: "232.1243",
+                message:
+                    "Should left no more than maxSuffix digits count in suffix - some maxSuffix case and actual suffix shorter",
+            },
+            {
+                max: null,
+                maxSuffix: 2,
+                test: "1323,23",
+                expected: "1323.23",
+                message: "Should replace comma with dot",
+            },
+            {
+                max: null,
+                maxSuffix: 8,
+                test: "434,343,3423",
+                expected: "434.343",
+                message: "Should remove all after the second comma and itself",
+            },
+            {
+                max: null,
+                maxSuffix: 8,
+                test: "434.343.3423",
+                expected: "434.343",
+                message: "Should remove all after the second dot and itself",
+            },
+            {
+                max: null,
+                maxSuffix: 8,
+                test: "`3|49(3.3@43f",
+                expected: "3493.343",
+                message: "Should remove all non-digits and non-dot symbols",
+            },
+            {
+                max: null,
+                maxSuffix: 8,
+                test: ".219",
+                expected: "0.219",
+                message: "Should add leading zero",
+            },
+            {
+                max: null,
+                maxSuffix: 8,
+                test: "32..219",
+                expected: "32.219",
+                message: "Should replace the series of dots with the only",
+            },
+            {
+                max: null,
+                maxSuffix: 8,
+                test: "32,,219",
+                expected: "32.219",
+                message: "Should replace the series of commas with the only",
+            },
+        ].forEach((testData) => {
+            it(testData.message, function () {
+                InputValuesProviders.provideFormatOfFloatValueByInputString(
+                    testData.test,
+                    testData.maxSuffix,
+                    testData.max
+                ).should.be.equal(testData.expected);
+            });
+        });
+
+        it("Should throw an error if passed suffix length less than 0", function () {
+            let error = null;
+            try {
+                InputValuesProviders.provideFormatOfFloatValueByInputString(
+                    "23232",
+                    -1
+                );
+            } catch (e) {
+                error = e;
+            }
+
+            (error?.message ?? "").should.startWith(
+                "Min suffix length is 0, got"
+            );
+        });
+    });
+});

package/src/components/tests/utils/urlQueryUtils/getQueryParameterValues.test.js

@@ -0,0 +1,71 @@
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+import { getQueryParameterValues } from "../../../utils/urlQueryUtils.js";
+
+describe("urlQueryUtils", function () {
+    describe("#getQueryParameterValues", function () {
+        beforeEach(function () {});
+
+        afterEach(function () {
+            global.window = {};
+        });
+
+        function setCustomQueryString(query) {
+            global.window = {
+                location: {
+                    search: query,
+                },
+            };
+        }
+
+        it("Should unescape parameter values", function () {
+            const parameterValuesWithSpecialSymbols = "#a@se /wer|*|##eee$";
+            setCustomQueryString(
+                `?a=${encodeURIComponent(parameterValuesWithSpecialSymbols)}`
+            );
+            const result = getQueryParameterValues("a");
+
+            result.should.be.deepEqual([
+                ...parameterValuesWithSpecialSymbols.split("|*|"),
+            ]);
+        });
+
+        it("Should return empty array if there is no such parameter in the query", function () {
+            setCustomQueryString(`?a=val&b=val2`);
+            const result = getQueryParameterValues("c");
+
+            result.should.be.deepEqual([]);
+        });
+
+        it("Should return array with the only empty string element if the value of the parameter is empty", function () {
+            setCustomQueryString(`?a=`);
+            const result = getQueryParameterValues("a");
+
+            result.should.be.deepEqual([""]);
+        });
+
+        it("Should return array with one value", function () {
+            setCustomQueryString(`?a=val1`);
+            const result = getQueryParameterValues("a");
+
+            result.should.be.deepEqual(["val1"]);
+        });
+
+        it("Should return array with several values", function () {
+            setCustomQueryString(`?a=${encodeURIComponent("val1|*|val2")}`);
+            const result = getQueryParameterValues("a");
+
+            result.should.be.deepEqual(["val1", "val2"]);
+        });
+
+        it("Should return array of all values if parameter is defined several times in the query", function () {
+            setCustomQueryString(
+                `?a=${encodeURIComponent("val1|*|val2")}&a=val3`
+            );
+            const result = getQueryParameterValues("a");
+
+            result.should.be.deepEqual(["val1", "val2", "val3"]);
+        });
+    });
+});

package/src/components/tests/utils/urlQueryUtils/saveQueryParameterAndValues.test.js

@@ -0,0 +1,144 @@
+import sinon from "sinon";
+import should from "should";
+
+import { beforeEach, afterEach, describe, it } from "vitest";
+import { saveQueryParameterAndValues } from "../../../utils/urlQueryUtils.js";
+
+describe("urlQueryUtils", function () {
+    describe("#saveQueryParameterAndValues", function () {
+        let callbackStub;
+        beforeEach(function () {
+            callbackStub = sinon.stub();
+        });
+
+        afterEach(function () {
+            global.window = {};
+        });
+
+        function setCustomQueryString(query) {
+            global.window = {
+                location: {
+                    search: query,
+                },
+            };
+        }
+
+        it("Should escape parameter values", function () {
+            setCustomQueryString("");
+            const result = saveQueryParameterAndValues(
+                "a",
+                ["e #e"],
+                callbackStub
+            );
+            result.should.be.equal(`?a=${encodeURIComponent("e #e")}`);
+        });
+
+        it("Should call callback ones", function () {
+            setCustomQueryString("");
+            saveQueryParameterAndValues("a", ["1"], callbackStub);
+            callbackStub.callCount.should.be.equal(1);
+        });
+
+        it("Should add parameter with no values - Case query is empty", function () {
+            setCustomQueryString("");
+            const result = saveQueryParameterAndValues("a", [], callbackStub);
+            result.should.be.equal("?a=");
+        });
+
+        it("Should add parameter with no values - Case query contains one parameter", function () {
+            setCustomQueryString("?one=val");
+            const result = saveQueryParameterAndValues("a", [], callbackStub);
+            result.should.be.equal("?one=val&a=");
+        });
+
+        it("Should add parameter with no values - Case query contains several parameters", function () {
+            setCustomQueryString("?one=val&err=week");
+            const result = saveQueryParameterAndValues("a", [], callbackStub);
+            result.should.be.equal("?one=val&err=week&a=");
+        });
+
+        it("Should add parameter with one value - Case query is empty", function () {
+            setCustomQueryString("");
+            const result = saveQueryParameterAndValues(
+                "a",
+                ["1"],
+                callbackStub
+            );
+            result.should.be.equal("?a=1");
+        });
+
+        it("Should add parameter with one value - Case query contains one parameter", function () {
+            setCustomQueryString("?one=val");
+            const result = saveQueryParameterAndValues(
+                "a",
+                ["1"],
+                callbackStub
+            );
+            result.should.be.equal("?one=val&a=1");
+        });
+
+        it("Should add parameter with one value - Case query contains several parameters", function () {
+            setCustomQueryString("?one=val&err=week");
+            const result = saveQueryParameterAndValues(
+                "a",
+                ["1"],
+                callbackStub
+            );
+            result.should.be.equal("?one=val&err=week&a=1");
+        });
+
+        it("Should add parameter with several values using separator - Case query is empty", function () {
+            setCustomQueryString("");
+            const result = saveQueryParameterAndValues(
+                "a",
+                ["1", "aa", "err"],
+                callbackStub
+            );
+            result.should.be.equal(`?a=${encodeURIComponent("1|*|aa|*|err")}`);
+        });
+
+        it("Should add parameter with several values using separator - Case query contains one parameter", function () {
+            setCustomQueryString("?one=val");
+            const result = saveQueryParameterAndValues(
+                "a",
+                ["1", "aa", "err"],
+                callbackStub
+            );
+            result.should.be.equal(
+                `?one=val&a=${encodeURIComponent("1|*|aa|*|err")}`
+            );
+        });
+
+        it("Should add parameter with several values using separator - Case query contains several parameters", function () {
+            setCustomQueryString("?one=val&err=week");
+            const result = saveQueryParameterAndValues(
+                "a",
+                ["1", "aa", "err"],
+                callbackStub
+            );
+            result.should.be.equal(
+                `?one=val&err=week&a=${encodeURIComponent("1|*|aa|*|err")}`
+            );
+        });
+
+        it("Should replace existing parameter value - Case query contains one parameter", function () {
+            setCustomQueryString("?a=val");
+            const result = saveQueryParameterAndValues(
+                "a",
+                ["1"],
+                callbackStub
+            );
+            result.should.be.equal("?a=1");
+        });
+
+        it("Should replace existing parameter value - Case query contains several parameters", function () {
+            setCustomQueryString("?one=val&a=week");
+            const result = saveQueryParameterAndValues(
+                "a",
+                ["1"],
+                callbackStub
+            );
+            result.should.be.equal("?one=val&a=1");
+        });
+    });
+});

package/src/components/utils/inputValueProviders.js

@@ -0,0 +1,58 @@
+import { BigNumber } from "bignumber.js";
+
+export class InputValuesProviders {
+    /**
+     * Designed to be called onKeyUp event of html input field for float value
+     * Removes all prohibited stuff from the given float string and remains only allowed.
+     * Removes digits before and after the dot.
+     *
+     * @param inputString {string} string to be corrected
+     * @param maxValue {string} max value for the correcting float value
+     * @param digitsAfterDot {number} count of digits after the dot that this method should provide, min 0
+     * @return {string} corrected float value string
+     */
+    static provideFormatOfFloatValueByInputString(
+        inputString,
+        digitsAfterDot = 2,
+        maxValue = null
+    ) {
+        let value = inputString;
+        if (!value) {
+            return "";
+        }
+
+        if (digitsAfterDot < 0) {
+            throw new Error("Min suffix length is 0, got " + digitsAfterDot);
+        }
+
+        value = value.replace(/[,]/g, "."); // replaces commas with dots
+        value = value.replace(/[^0-9.]/g, ""); // remove non digits/dots
+        value = value.replace(/^\./g, "0."); // adds leading zero
+        value = value.replace(/\.+/g, "."); // replaces series of dots with single dot
+
+        let parts = value.split(".");
+        if (parts.length > 2) {
+            // removes all after second dot and itself
+            parts = [parts[0], parts[1]];
+        }
+
+        if (maxValue != null) {
+            const maxDigitsCountBeforeTheDot =
+                BigNumber(maxValue).toFixed(0).length;
+            if (parts[0]?.length > maxDigitsCountBeforeTheDot) {
+                // removes redundant prefix digits
+                parts[0] = parts[0].substring(
+                    parts[0].length - maxDigitsCountBeforeTheDot,
+                    parts[0].length
+                );
+            }
+        }
+
+        if (parts[1]?.length > digitsAfterDot) {
+            // removes redundant suffix digits
+            parts[1] = parts[1].substring(0, digitsAfterDot);
+        }
+
+        return parts.join(".");
+    }
+}

package/src/index.js

@@ -7,6 +7,7 @@ export { AssetIcon } from "./components/atoms/AssetIcon/AssetIcon.jsx";
 export { useCallHandlingErrors } from "./components/hooks/useCallHandlingErrors.js";
 export { useReferredState } from "./components/hooks/useReferredState.js";
 export { handleClickOutside } from "./components/utils/uiUtils.js";
+export { InputValuesProviders } from "./components/utils/inputValueProviders.js";
 
 export { saveQueryParameterAndValues } from "./components/utils/urlQueryUtils.js";
 export { removeQueryParameterAndValues } from "./components/utils/urlQueryUtils.js";
@@ -31,6 +32,7 @@ export { postponeExecution } from "./common/utils/postponeExecution.js";
 export { AxiosAdapter } from "./common/adapters/axiosAdapter.js";
 
 export { EmailsApi } from "./common/utils/emailAPI.js";
+export { IpAddressProvider } from "./common/external-apis/ipAddressProviders.js";
 
 // Robust data retriever service and related APIs
 export { CacheAndConcurrentRequestsResolver } from "./robustExteranlApiCallerService/cacheAndConcurrentRequestsResolver.js";