@lifi/widget 1.26.2 → 1.26.4

package/stores/routes/useRouteExecutionStore.js

@@ -1,67 +1,95 @@
 import create from 'zustand';
 import { persist } from 'zustand/middleware';
-import { immer } from 'zustand/middleware/immer';
 import { hasEnumFlag } from '../../utils';
 import { RouteExecutionStatus } from './types';
 import { isRouteDone, isRouteFailed, isRoutePartiallyDone, isRouteRefunded, } from './utils';
-export const useRouteExecutionStore = create()(persist(immer((set) => ({
+export const useRouteExecutionStore = create()(persist((set, get) => ({
     routes: {},
-    setExecutableRoute: (route) => set((state) => {
-        if (!state.routes[route.id]) {
-            // clean previous idle routes that were not executed
-            Object.keys(state.routes)
-                .filter((routeId) => { var _a; return ((_a = state.routes[routeId]) === null || _a === void 0 ? void 0 : _a.status) === RouteExecutionStatus.Idle; })
-                .forEach((routeId) => delete state.routes[routeId]);
-            state.routes[route.id] = {
-                route,
-                status: RouteExecutionStatus.Idle,
-            };
+    setExecutableRoute: (route) => {
+        if (!get().routes[route.id]) {
+            set((state) => {
+                const routes = Object.assign({}, state.routes);
+                // clean previous idle routes that were not executed
+                Object.keys(routes)
+                    .filter((routeId) => { var _a; return ((_a = routes[routeId]) === null || _a === void 0 ? void 0 : _a.status) === RouteExecutionStatus.Idle; })
+                    .forEach((routeId) => delete routes[routeId]);
+                routes[route.id] = {
+                    route,
+                    status: RouteExecutionStatus.Idle,
+                };
+                return {
+                    routes,
+                };
+            });
         }
-    }),
-    updateRoute: (route) => set((state) => {
-        if (state.routes[route.id]) {
-            state.routes[route.id].route = route;
-            const isFailed = isRouteFailed(route);
-            if (isFailed) {
-                state.routes[route.id].status = RouteExecutionStatus.Failed;
-                return;
-            }
-            const isDone = isRouteDone(route);
-            if (isDone) {
-                state.routes[route.id].status = RouteExecutionStatus.Done;
-                if (isRoutePartiallyDone(route)) {
-                    state.routes[route.id].status |= RouteExecutionStatus.Partial;
+    },
+    updateRoute: (route) => {
+        if (get().routes[route.id]) {
+            set((state) => {
+                const updatedState = {
+                    routes: Object.assign(Object.assign({}, state.routes), { [route.id]: Object.assign(Object.assign({}, state.routes[route.id]), { route }) }),
+                };
+                const isFailed = isRouteFailed(route);
+                if (isFailed) {
+                    updatedState.routes[route.id].status =
+                        RouteExecutionStatus.Failed;
+                    return updatedState;
                 }
-                else if (isRouteRefunded(route)) {
-                    state.routes[route.id].status |= RouteExecutionStatus.Refunded;
+                const isDone = isRouteDone(route);
+                if (isDone) {
+                    updatedState.routes[route.id].status = RouteExecutionStatus.Done;
+                    if (isRoutePartiallyDone(route)) {
+                        updatedState.routes[route.id].status |=
+                            RouteExecutionStatus.Partial;
+                    }
+                    else if (isRouteRefunded(route)) {
+                        updatedState.routes[route.id].status |=
+                            RouteExecutionStatus.Refunded;
+                    }
+                    return updatedState;
                 }
-                return;
-            }
-            const isLoading = route.steps.some((step) => step.execution);
-            if (isLoading) {
-                state.routes[route.id].status = RouteExecutionStatus.Pending;
-            }
+                const isLoading = route.steps.some((step) => step.execution);
+                if (isLoading) {
+                    updatedState.routes[route.id].status =
+                        RouteExecutionStatus.Pending;
+                }
+                return updatedState;
+            });
         }
-    }),
-    restartRoute: (routeId) => set((state) => {
-        state.routes[routeId].status = RouteExecutionStatus.Pending;
-    }),
-    deleteRoute: (routeId) => set((state) => {
-        if (state.routes[routeId]) {
-            delete state.routes[routeId];
+    },
+    restartRoute: (routeId) => {
+        if (get().routes[routeId]) {
+            set((state) => ({
+                routes: Object.assign(Object.assign({}, state.routes), { [routeId]: Object.assign(Object.assign({}, state.routes[routeId]), { status: RouteExecutionStatus.Pending }) }),
+            }));
         }
-    }),
+    },
+    deleteRoute: (routeId) => {
+        if (get().routes[routeId]) {
+            set((state) => {
+                const routes = Object.assign({}, state.routes);
+                delete routes[routeId];
+                return {
+                    routes,
+                };
+            });
+        }
+    },
     deleteRoutes: (type) => set((state) => {
-        Object.keys(state.routes)
+        const routes = Object.assign({}, state.routes);
+        Object.keys(routes)
             .filter((routeId) => {
             var _a, _b, _c, _d;
             return type === 'completed'
-                ? hasEnumFlag((_b = (_a = state.routes[routeId]) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 0, RouteExecutionStatus.Done)
-                : !hasEnumFlag((_d = (_c = state.routes[routeId]) === null || _c === void 0 ? void 0 : _c.status) !== null && _d !== void 0 ? _d : 0, RouteExecutionStatus.Done);
+                ? hasEnumFlag((_b = (_a = routes[routeId]) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : 0, RouteExecutionStatus.Done)
+                : !hasEnumFlag((_d = (_c = routes[routeId]) === null || _c === void 0 ? void 0 : _c.status) !== null && _d !== void 0 ? _d : 0, RouteExecutionStatus.Done);
         })
-            .forEach((routeId) => delete state.routes[routeId]);
+            .forEach((routeId) => delete routes[routeId]);
+        return {
+            routes,
+        };
     }),
-})), {
+}), {
     name: 'li.fi-widget-routes',
     version: 1,
     partialize: (state) => ({ routes: state.routes }),

package/stores/settings/useSettingsStore.d.ts

@@ -2,7 +2,7 @@ import type { WidgetConfig } from '../../types';
 import type { SettingsState, SettingsStore } from './types';
 export declare const defaultConfigurableSettings: Pick<SettingsState, 'routePriority' | 'slippage'>;
 export declare const defaultSettings: SettingsState;
-export declare const useSettingsStore: import("zustand").UseBoundStore<Omit<Omit<import("zustand").StoreApi<SettingsStore>, "persist"> & {
+export declare const useSettingsStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SettingsStore>, "persist"> & {
     persist: {
         setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SettingsStore, {
             setValue: import("./types").ValueSetter<SettingsState>;
@@ -40,7 +40,5 @@ export declare const useSettingsStore: import("zustand").UseBoundStore<Omit<Omit
             _enabledExchanges?: Record<string, boolean> | undefined;
         }>>;
     };
-}, "setState"> & {
-    setState(nextStateOrUpdater: SettingsStore | Partial<SettingsStore> | ((state: import("immer/dist/internal").WritableDraft<SettingsStore>) => void), shouldReplace?: boolean | undefined): void;
 }>;
 export declare const setDefaultSettings: (config?: WidgetConfig) => void;

package/stores/settings/useSettingsStore.js

@@ -12,7 +12,6 @@ var __rest = (this && this.__rest) || function (s, e) {
 /* eslint-disable no-underscore-dangle */
 import create from 'zustand';
 import { persist } from 'zustand/middleware';
-import { immer } from 'zustand/middleware/immer';
 import { SettingsToolTypes } from './types';
 export const defaultConfigurableSettings = {
     routePriority: 'RECOMMENDED',
@@ -24,45 +23,51 @@ export const defaultSettings = {
     advancedPreferences: false,
     showDestinationWallet: true,
 };
-export const useSettingsStore = create()(persist(immer((set) => (Object.assign(Object.assign({}, defaultSettings), { setValue: (key, value) => set((state) => {
-        state[key] = value;
-    }), setValues: (values) => set((state) => {
+export const useSettingsStore = create()(persist((set) => (Object.assign(Object.assign({}, defaultSettings), { setValue: (key, value) => set(() => ({
+        [key]: value,
+    })), setValues: (values) => set((state) => {
+        const updatedState = Object.assign({}, state);
         for (const key in values) {
-            if (Object.prototype.hasOwnProperty.call(state, key)) {
-                state[key] = values[key];
+            if (Object.hasOwn(state, key)) {
+                updatedState[key] = values[key];
             }
         }
-    }), initializeTools: (toolType, tools) => set((state) => {
+        return updatedState;
+    }), initializeTools: (toolType, tools) => {
         if (!tools.length) {
             return;
         }
-        if (state[`_enabled${toolType}`]) {
-            // Add a new tools
-            const enabledTools = tools
-                .filter((tool) => !Object.prototype.hasOwnProperty.call(state[`_enabled${toolType}`], tool))
-                .reduce((values, tool) => {
-                values[tool] = true;
-                return values;
-            }, state[`_enabled${toolType}`]);
-            // Filter tools we no longer have
-            state[`_enabled${toolType}`] = Object.fromEntries(Object.entries(enabledTools).filter(([key]) => tools.includes(key)));
-        }
-        else {
-            state[`_enabled${toolType}`] = tools.reduce((values, tool) => {
-                values[tool] = true;
-                return values;
-            }, {});
-        }
-        state[`enabled${toolType}`] = Object.entries(state[`_enabled${toolType}`])
-            .filter(([_, value]) => value)
-            .map(([key]) => key);
-    }), setTools: (toolType, tools, availableTools) => set((state) => {
-        state[`enabled${toolType}`] = tools;
-        state[`_enabled${toolType}`] = availableTools.reduce((values, tool) => {
+        set((state) => {
+            const updatedState = Object.assign({}, state);
+            if (updatedState[`_enabled${toolType}`]) {
+                // Add a new tools
+                const enabledTools = tools
+                    .filter((tool) => !Object.hasOwn(updatedState[`_enabled${toolType}`], tool))
+                    .reduce((values, tool) => {
+                    values[tool] = true;
+                    return values;
+                }, updatedState[`_enabled${toolType}`]);
+                // Filter tools we no longer have
+                updatedState[`_enabled${toolType}`] = Object.fromEntries(Object.entries(enabledTools).filter(([key]) => tools.includes(key)));
+            }
+            else {
+                updatedState[`_enabled${toolType}`] = tools.reduce((values, tool) => {
+                    values[tool] = true;
+                    return values;
+                }, {});
+            }
+            updatedState[`enabled${toolType}`] = Object.entries(updatedState[`_enabled${toolType}`])
+                .filter(([_, value]) => value)
+                .map(([key]) => key);
+            return updatedState;
+        });
+    }, setTools: (toolType, tools, availableTools) => set(() => ({
+        [`enabled${toolType}`]: tools,
+        [`_enabled${toolType}`]: availableTools.reduce((values, tool) => {
             values[tool.key] = tools.includes(tool.key);
             return values;
-        }, {});
-    }) }))), {
+        }, {}),
+    })) })), {
     name: 'li.fi-widget-settings',
     version: 2,
     partialize: (state) => {