@layerswap/widget 1.0.4 → 1.0.6

package/dist/esm/lib/axiosInterceptor.js

@@ -13,7 +13,7 @@ export const InitializeAuthInstance = (baseURL) => {
             config.headers["X-LS-APIKEY"] = apiKey;
         }
         else {
-            throw new Error("NEXT_PUBLIC_API_KEY is not set up in env vars");
+            throw new Error("Api key is not provided");
         }
         return config;
     }, (error) => {
@@ -34,7 +34,7 @@ export const InitializeUnauthInstance = (baseURL) => {
             config.headers["X-LS-APIKEY"] = apiKey;
         }
         else {
-            throw new Error("NEXT_PUBLIC_API_KEY is not set up in env vars");
+            throw new Error("Api key is not provided");
         }
         return config;
     }, (error) => {

package/dist/esm/stores/balanceStore.js

@@ -19,8 +19,11 @@ function processQueue() {
 export const useBalanceStore = create()(subscribeWithSelector((set, get, api) => ({
     balances: {},
     lastFetchMap: {},
+    balanceKeysForSorting: {},
     initiatedBalances: null,
-    isLoading: false,
+    sortingDataIsLoading: false,
+    partialPublished: false,
+    startTimeOfInit: undefined,
     fetchBalance: (address, network, options) => {
         const key = getKey(address, network);
         const entry = get().balances[key];
@@ -76,92 +79,56 @@ export const useBalanceStore = create()(subscribeWithSelector((set, get, api) =>
         }));
         return queuedPromise;
     },
-    initAllBalances: pairs => {
-        if (pairs.length > 0)
-            set({ isLoading: true });
-        set({ initiatedBalances: null });
-        // kick off every fetch
-        pairs.forEach(({ address, network }) => {
-            get().fetchBalance(address, network, { dedupeInterval: 120000, ignoreCache: true, timeoutMs: 4000, retryCount: 0 });
+    initSortingBalances: pairs => {
+        const initiatedBalances = pairs.reduce((acc, { address, network }) => {
+            const key = getKey(address, network);
+            acc[network.name] = key;
+            return acc;
+        }, {});
+        const sortedpairs = pairs.sort((a, b) => Number(a.network.source_rank) - Number(b.network.source_rank));
+        sortedpairs.forEach(({ address, network }) => {
+            get().fetchBalance(address, network, { dedupeInterval: 120000, ignoreCache: false, retryCount: 0 });
         });
-        // subscribe to balance map changes
-        const unsub = api.subscribe(state => state.balances, balances => {
-            const done = pairs.every(({ address, network }) => balances[getKey(address, network)]?.status !== 'loading');
+        set({ sortingDataIsLoading: true });
+        set({ initiatedBalances });
+        set({ startTimeOfInit: Date.now() });
+        set({ partialPublished: false });
+        api.subscribe(state => state.balances, balances => {
+            const keysArray = Object.entries(get().initiatedBalances || {});
+            const done = keysArray.every(([_, key]) => balances[key].data);
             if (done) {
-                const finalMap = pairs.reduce((acc, { address, network }) => {
-                    const key = getKey(address, network);
-                    const entry = balances[key];
-                    if (entry)
-                        acc[network.name] = key;
-                    return acc;
-                }, {});
-                set({ initiatedBalances: finalMap });
-                set({ isLoading: false });
-                unsub(); // cleanup subscription
+                set({ sortingDataIsLoading: false });
+                set({ balanceKeysForSorting: get().initiatedBalances });
+                set({ partialPublished: false });
             }
-        });
-    },
-    getResolvedInitiatedBalances: () => {
-        const keys = get().initiatedBalances;
-        if (!keys)
-            return null;
-        const balances = get().balances;
-        return Object.entries(keys).reduce((acc, [networkName, key]) => {
-            const entry = balances[key];
-            if (entry?.data)
-                acc[networkName] = entry.data;
-            return acc;
-        }, {});
+            else {
+                const startedAt = get().startTimeOfInit ?? 0;
+                const elapsed = Date.now() - startedAt;
+                if (!get().partialPublished && elapsed >= 3000) {
+                    const partial = {};
+                    keysArray.forEach(([networkName, key]) => {
+                        if (balances[key]?.data) {
+                            partial[networkName] = key;
+                        }
+                    });
+                    set({ balanceKeysForSorting: partial });
+                    set({ partialPublished: true });
+                    set({ sortingDataIsLoading: false });
+                }
+            }
+        }, { fireImmediately: true });
     }
 })));
-// Memoized selector to prevent unnecessary object creation
-let lastInitiatedBalances = null;
-let lastBalances = {};
-let memoizedResult = null;
-//Discuss with Babken M.
-export const selectResolvedInitiatedBalances = (state) => {
-    const keys = state.initiatedBalances;
+export const selectResolvedSortingBalances = (state) => {
+    const keys = state.balanceKeysForSorting;
     if (!keys)
         return null;
-    // Only recalculate if initiatedBalances or balances have actually changed
-    if (keys === lastInitiatedBalances && state.balances === lastBalances && memoizedResult) {
-        return memoizedResult;
-    }
-    // Check if the actual data has changed, not just the object references
-    if (lastInitiatedBalances && memoizedResult) {
-        let hasChanged = false;
-        // Check if keys are different
-        const currentKeySet = Object.keys(keys);
-        const lastKeySet = Object.keys(lastInitiatedBalances);
-        if (currentKeySet.length !== lastKeySet.length ||
-            !currentKeySet.every(k => lastKeySet.includes(k))) {
-            hasChanged = true;
-        }
-        // Check if balance data has changed for existing keys
-        if (!hasChanged) {
-            for (const [_, key] of Object.entries(keys)) {
-                const entry = state.balances[key];
-                const lastEntry = lastBalances[key];
-                if (entry?.data !== lastEntry?.data) {
-                    hasChanged = true;
-                    break;
-                }
-            }
-        }
-        if (!hasChanged) {
-            return memoizedResult;
-        }
-    }
-    // Recalculate the result
-    const result = Object.entries(keys).reduce((acc, [networkName, key]) => {
+    const keysArray = Object.entries(keys);
+    const balanceData = keysArray.reduce((acc, [networkName, key]) => {
         const entry = state.balances[key];
         if (entry?.data)
             acc[networkName] = entry.data;
         return acc;
     }, {});
-    // Update memoization cache
-    lastInitiatedBalances = keys;
-    lastBalances = state.balances;
-    memoizedResult = result;
-    return result;
+    return balanceData;
 };