@lifi/widget 0.0.0-preview-6cc63bac

package/dist/esm/stores/routes/createRouteExecutionStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRouteExecutionStore.js","names":[],"sources":["../../../../src/stores/routes/createRouteExecutionStore.ts"],"sourcesContent":["import type { Route, RouteExtended } from '@lifi/sdk'\nimport type { StoreApi, UseBoundStore } from 'zustand'\nimport { create } from 'zustand'\nimport { persist } from 'zustand/middleware'\nimport { hasEnumFlag } from '../../utils/enum.js'\nimport type { PersistStoreProps } from '../types.js'\nimport type { RouteExecution, RouteExecutionState } from './types.js'\nimport { RouteExecutionStatus } from './types.js'\nimport {\n  isRouteDone,\n  isRouteFailed,\n  isRoutePartiallyDone,\n  isRouteRefunded,\n} from './utils.js'\n\nexport const createRouteExecutionStore = ({\n  namePrefix,\n}: PersistStoreProps): UseBoundStore<StoreApi<RouteExecutionState>> =>\n  create<RouteExecutionState>()(\n    persist(\n      (set, get) => ({\n        routes: {},\n        setExecutableRoute: (route: Route, observableRouteIds?: string[]) => {\n          if (!get().routes[route.id]) {\n            set((state: RouteExecutionState) => {\n              const routes = { ...state.routes }\n              // clean previous idle routes\n              Object.keys(routes)\n                .filter(\n                  (routeId) =>\n                    !observableRouteIds?.includes(routeId) &&\n                    hasEnumFlag(\n                      routes[routeId]!.status,\n                      RouteExecutionStatus.Idle\n                    )\n                )\n                .forEach((routeId) => {\n                  delete routes[routeId]\n                })\n              routes[route.id] = {\n                route,\n                status: RouteExecutionStatus.Idle,\n              }\n              return {\n                routes,\n              }\n            })\n          }\n        },\n        updateRoute: (route: RouteExtended) => {\n          if (get().routes[route.id]) {\n            set((state: RouteExecutionState) => {\n              const updatedState = {\n                routes: {\n                  ...state.routes,\n                  [route.id]: { ...state.routes[route.id]!, route },\n                },\n              }\n              const isFailed = isRouteFailed(route)\n              if (isFailed) {\n                updatedState.routes[route.id]!.status =\n                  RouteExecutionStatus.Failed\n                return updatedState\n              }\n              const isDone = isRouteDone(route)\n              if (isDone) {\n                updatedState.routes[route.id]!.status =\n                  RouteExecutionStatus.Done\n                if (isRoutePartiallyDone(route)) {\n                  updatedState.routes[route.id]!.status |=\n                    RouteExecutionStatus.Partial\n                } else if (isRouteRefunded(route)) {\n                  updatedState.routes[route.id]!.status |=\n                    RouteExecutionStatus.Refunded\n                }\n                return updatedState\n              }\n              const isLoading = route.steps.some((step) => step.execution)\n              if (isLoading) {\n                updatedState.routes[route.id]!.status =\n                  RouteExecutionStatus.Pending\n              }\n              return updatedState\n            })\n          }\n        },\n        deleteRoutes: (type, accountAddresses) =>\n          set((state: RouteExecutionState) => {\n            const routes = { ...state.routes }\n            Object.keys(routes)\n              .filter((routeId) => {\n                const route = routes[routeId]\n                if (\n                  accountAddresses &&\n                  !accountAddresses.includes(route?.route.fromAddress ?? '')\n                ) {\n                  return false\n                }\n                return type === 'completed'\n                  ? hasEnumFlag(route?.status ?? 0, RouteExecutionStatus.Done)\n                  : type === 'failed'\n                    ? hasEnumFlag(\n                        route?.status ?? 0,\n                        RouteExecutionStatus.Failed\n                      )\n                    : !hasEnumFlag(\n                        route?.status ?? 0,\n                        RouteExecutionStatus.Done\n                      )\n              })\n              .forEach((routeId) => {\n                delete routes[routeId]\n              })\n            return {\n              routes,\n            }\n          }),\n        deleteRoute: (routeId: string) => {\n          if (get().routes[routeId]) {\n            set((state: RouteExecutionState) => {\n              const routes = { ...state.routes }\n              delete routes[routeId]\n              return {\n                routes,\n              }\n            })\n          }\n        },\n      }),\n      {\n        name: `${namePrefix || 'li.fi'}-widget-routes`,\n        // Bump version on breaking changes to the stored structure.\n        version: 4,\n        // Clear stored routes on any version mismatch to avoid errors from incompatible data shapes.\n        migrate: () => ({ routes: {} }),\n        partialize: (state) => ({ routes: state.routes }),\n        merge: (persistedState: any, currentState: RouteExecutionState) => {\n          const state = {\n            ...currentState,\n            ...persistedState,\n          } as RouteExecutionState\n          try {\n            // Keep only the most recent 100 routes, evicting the oldest when the\n            // limit is exceeded.\n            const maxStoredRoutes = 100\n            const allRoutes = Object.values(state.routes) as RouteExecution[]\n            const storedRoutes = allRoutes\n              .sort(\n                (a, b) =>\n                  (b.route.steps[0]?.execution?.startedAt ?? 0) -\n                  (a.route.steps[0]?.execution?.startedAt ?? 0)\n              )\n              .slice(0, maxStoredRoutes)\n            const keepIds = new Set(storedRoutes.map((r) => r.route.id))\n            for (const id of Object.keys(state.routes)) {\n              if (!keepIds.has(id)) {\n                delete state.routes[id]\n              }\n            }\n          } catch (error) {\n            console.error(error)\n          }\n          return state\n        },\n      }\n    )\n  )\n"],"mappings":"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"}

package/dist/esm/stores/routes/useIntermediateRoutesStore.js

@@ -0,0 +1,19 @@
+import { create } from "zustand";
+//#region src/stores/routes/useIntermediateRoutesStore.ts
+const useIntermediateRoutesStore = create((set, get) => ({
+	intermediateRoutes: {},
+	setIntermediateRoutes: (key, routes) => {
+		const stringKey = JSON.stringify(key);
+		const newRoutesByKey = {};
+		newRoutesByKey[stringKey] = routes;
+		set({ intermediateRoutes: newRoutesByKey });
+	},
+	getIntermediateRoutes: (key) => {
+		const stringKey = JSON.stringify(key);
+		return get().intermediateRoutes[stringKey];
+	}
+}));
+//#endregion
+export { useIntermediateRoutesStore };
+
+//# sourceMappingURL=useIntermediateRoutesStore.js.map

package/dist/esm/stores/routes/useIntermediateRoutesStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIntermediateRoutesStore.js","names":[],"sources":["../../../../src/stores/routes/useIntermediateRoutesStore.ts"],"sourcesContent":["import type { Route } from '@lifi/sdk'\nimport type { StoreApi, UseBoundStore } from 'zustand'\nimport { create } from 'zustand'\n\ninterface IntermediateRoutesState {\n  intermediateRoutes: Record<string, Route[] | undefined>\n  setIntermediateRoutes: (\n    key: readonly unknown[],\n    routes: Route[] | undefined\n  ) => void\n  getIntermediateRoutes: (key: readonly unknown[]) => Route[] | undefined\n}\n\nexport const useIntermediateRoutesStore: UseBoundStore<\n  StoreApi<IntermediateRoutesState>\n> = create<IntermediateRoutesState>((set, get) => ({\n  intermediateRoutes: {},\n  setIntermediateRoutes: (key, routes) => {\n    const stringKey = JSON.stringify(key)\n    // Create a new state with only the current key\n    const newRoutesByKey: Record<string, Route[] | undefined> = {}\n    newRoutesByKey[stringKey] = routes\n    set({ intermediateRoutes: newRoutesByKey })\n  },\n  getIntermediateRoutes: (key) => {\n    const stringKey = JSON.stringify(key)\n    return get().intermediateRoutes[stringKey]\n  },\n}))\n"],"mappings":";;AAaA,MAAa,6BAET,QAAiC,KAAK,SAAS;CACjD,oBAAoB,CAAC;CACrB,wBAAwB,KAAK,WAAW;EACtC,MAAM,YAAY,KAAK,UAAU,GAAG;EAEpC,MAAM,iBAAsD,CAAC;EAC7D,eAAe,aAAa;EAC5B,IAAI,EAAE,oBAAoB,eAAe,CAAC;CAC5C;CACA,wBAAwB,QAAQ;EAC9B,MAAM,YAAY,KAAK,UAAU,GAAG;EACpC,OAAO,IAAI,EAAE,mBAAmB;CAClC;AACF,EAAE"}

package/dist/esm/stores/routes/useRouteExecutionIndicator.js

@@ -0,0 +1,23 @@
+import { useRouteExecutionStore } from "./RouteExecutionStore.js";
+import { useCallback, useMemo } from "react";
+import { useAccount } from "@lifi/wallet-management";
+//#region src/stores/routes/useRouteExecutionIndicator.ts
+const isRecentTransaction = (route) => {
+	const startedAt = route.route.steps[0]?.execution?.startedAt ?? 0;
+	return startedAt > 0 && Date.now() - startedAt < 1e3 * 60 * 60 * 24;
+};
+const useRouteExecutionIndicator = () => {
+	const { accounts } = useAccount();
+	const accountAddresses = useMemo(() => accounts.map((account) => account.address), [accounts]);
+	return useRouteExecutionStore(useCallback((state) => {
+		const recentOwnedRoutes = Object.values(state.routes).filter((route) => accountAddresses.includes(route.route.fromAddress) && isRecentTransaction(route));
+		return {
+			failed: recentOwnedRoutes.some((r) => r.status === 8),
+			active: recentOwnedRoutes.some((r) => r.status === 2)
+		};
+	}, [accountAddresses]));
+};
+//#endregion
+export { useRouteExecutionIndicator };
+
+//# sourceMappingURL=useRouteExecutionIndicator.js.map

package/dist/esm/stores/routes/useRouteExecutionIndicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRouteExecutionIndicator.js","names":[],"sources":["../../../../src/stores/routes/useRouteExecutionIndicator.ts"],"sourcesContent":["import { useAccount } from '@lifi/wallet-management'\nimport { useCallback, useMemo } from 'react'\nimport { useRouteExecutionStore } from './RouteExecutionStore.js'\nimport type { RouteExecution, RouteExecutionState } from './types.js'\nimport { RouteExecutionStatus } from './types.js'\n\nexport type RouteExecutionIndicator = {\n  failed: boolean\n  active: boolean\n}\n\nconst isRecentTransaction = (route: RouteExecution): boolean => {\n  const startedAt = route.route.steps[0]?.execution?.startedAt ?? 0\n  return startedAt > 0 && Date.now() - startedAt < 1000 * 60 * 60 * 24 // 1 day\n}\n\nexport const useRouteExecutionIndicator = (): RouteExecutionIndicator => {\n  const { accounts } = useAccount()\n  const accountAddresses = useMemo(\n    () => accounts.map((account) => account.address),\n    [accounts]\n  )\n  const selector = useCallback(\n    (state: RouteExecutionState): RouteExecutionIndicator => {\n      const routes = Object.values(state.routes) as RouteExecution[]\n      const recentOwnedRoutes = routes.filter(\n        (route) =>\n          accountAddresses.includes(route.route.fromAddress) &&\n          isRecentTransaction(route)\n      )\n      return {\n        failed: recentOwnedRoutes.some(\n          (r) => r.status === RouteExecutionStatus.Failed\n        ),\n        active: recentOwnedRoutes.some(\n          (r) => r.status === RouteExecutionStatus.Pending\n        ),\n      }\n    },\n    [accountAddresses]\n  )\n  return useRouteExecutionStore(selector)\n}\n"],"mappings":";;;;AAWA,MAAM,uBAAuB,UAAmC;CAC9D,MAAM,YAAY,MAAM,MAAM,MAAM,IAAI,WAAW,aAAa;CAChE,OAAO,YAAY,KAAK,KAAK,IAAI,IAAI,YAAY,MAAO,KAAK,KAAK;AACpE;AAEA,MAAa,mCAA4D;CACvE,MAAM,EAAE,aAAa,WAAW;CAChC,MAAM,mBAAmB,cACjB,SAAS,KAAK,YAAY,QAAQ,OAAO,GAC/C,CAAC,QAAQ,CACX;CAoBA,OAAO,uBAnBU,aACd,UAAwD;EAEvD,MAAM,oBADS,OAAO,OAAO,MAAM,MACJ,EAAE,QAC9B,UACC,iBAAiB,SAAS,MAAM,MAAM,WAAW,KACjD,oBAAoB,KAAK,CAC7B;EACA,OAAO;GACL,QAAQ,kBAAkB,MACvB,MAAM,EAAE,WAAA,CACX;GACA,QAAQ,kBAAkB,MACvB,MAAM,EAAE,WAAA,CACX;EACF;CACF,GACA,CAAC,gBAAgB,CAEkB,CAAC;AACxC"}

package/dist/esm/stores/routes/useSetExecutableRoute.js

@@ -0,0 +1,9 @@
+import { useRouteExecutionStore } from "./RouteExecutionStore.js";
+//#region src/stores/routes/useSetExecutableRoute.ts
+const useSetExecutableRoute = () => {
+	return useRouteExecutionStore((state) => state.setExecutableRoute);
+};
+//#endregion
+export { useSetExecutableRoute };
+
+//# sourceMappingURL=useSetExecutableRoute.js.map

package/dist/esm/stores/routes/useSetExecutableRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSetExecutableRoute.js","names":[],"sources":["../../../../src/stores/routes/useSetExecutableRoute.ts"],"sourcesContent":["import { useRouteExecutionStore } from './RouteExecutionStore.js'\nimport type { RouteExecutionState } from './types.js'\n\nexport const useSetExecutableRoute =\n  (): RouteExecutionState['setExecutableRoute'] => {\n    return useRouteExecutionStore((state) => state.setExecutableRoute)\n  }\n"],"mappings":";;AAGA,MAAa,8BACsC;CAC/C,OAAO,wBAAwB,UAAU,MAAM,kBAAkB;AACnE"}

package/dist/esm/stores/routes/utils.js

@@ -0,0 +1,35 @@
+import microdiff from "microdiff";
+//#region src/stores/routes/utils.ts
+const isRouteDone = (route) => {
+	return route.steps.every((step) => step.execution?.status === "DONE");
+};
+const isRoutePartiallyDone = (route) => {
+	return route.steps.some((step) => step.execution?.actions?.some((action) => action.substatus === "PARTIAL"));
+};
+const isRouteRefunded = (route) => {
+	return route.steps.some((step) => step.execution?.actions?.some((action) => action.substatus === "REFUNDED"));
+};
+const isRouteFailed = (route) => {
+	return route.steps.some((step) => step.execution?.status === "FAILED");
+};
+const isRouteActive = (route) => {
+	if (!route) return false;
+	const isDone = isRouteDone(route);
+	const isFailed = isRouteFailed(route);
+	const alreadyStarted = route.steps.some((step) => step.execution);
+	return !isDone && !isFailed && alreadyStarted;
+};
+const getUpdatedAction = (currentRoute, updatedRoute) => {
+	const actionDiff = microdiff(currentRoute, updatedRoute).find((diff) => diff.path.includes("actions"));
+	if (!actionDiff) return;
+	const actionDiffIndex = actionDiff.path.indexOf("actions") + 2;
+	return actionDiff.path.slice(0, actionDiffIndex).reduce((obj, path) => obj[path], updatedRoute);
+};
+const getSourceTxHash = (route) => {
+	const sourceAction = route?.steps[0].execution?.actions?.filter((action) => !["RESET_ALLOWANCE", "SET_ALLOWANCE"].includes(action.type)).find((action) => action.txHash || action.taskId);
+	return sourceAction?.txHash || sourceAction?.taskId;
+};
+//#endregion
+export { getSourceTxHash, getUpdatedAction, isRouteActive, isRouteDone, isRouteFailed, isRoutePartiallyDone, isRouteRefunded };
+
+//# sourceMappingURL=utils.js.map

package/dist/esm/stores/routes/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../../src/stores/routes/utils.ts"],"sourcesContent":["import type { ExecutionAction, RouteExtended } from '@lifi/sdk'\nimport microdiff from 'microdiff'\n\nexport const isRouteDone = (route: RouteExtended): boolean => {\n  return route.steps.every((step) => step.execution?.status === 'DONE')\n}\n\nexport const isRoutePartiallyDone = (route: RouteExtended): boolean => {\n  return route.steps.some((step) =>\n    step.execution?.actions?.some((action) => action.substatus === 'PARTIAL')\n  )\n}\n\nexport const isRouteRefunded = (route: RouteExtended): boolean => {\n  return route.steps.some((step) =>\n    step.execution?.actions?.some((action) => action.substatus === 'REFUNDED')\n  )\n}\n\nexport const isRouteFailed = (route: RouteExtended): boolean => {\n  return route.steps.some((step) => step.execution?.status === 'FAILED')\n}\n\nexport const isRouteActive = (route?: RouteExtended): boolean => {\n  if (!route) {\n    return false\n  }\n  const isDone = isRouteDone(route)\n  const isFailed = isRouteFailed(route)\n  const alreadyStarted = route.steps.some((step) => step.execution)\n  return !isDone && !isFailed && alreadyStarted\n}\n\nexport const getUpdatedAction = (\n  currentRoute: RouteExtended,\n  updatedRoute: RouteExtended\n): ExecutionAction | undefined => {\n  const actionDiff = microdiff(currentRoute, updatedRoute).find((diff) =>\n    diff.path.includes('actions')\n  )\n  if (!actionDiff) {\n    return undefined\n  }\n  // Find action index in the diff array so we can slice the complete action object\n  // e.g. ['steps', 0, 'execution', 'actions', 0, 'message']\n  const actionDiffIndex = actionDiff.path.indexOf('actions') + 2\n  const actionPathSlice = actionDiff.path.slice(0, actionDiffIndex)\n  // Reduce updated route using the diff path to get updated process\n  const action = actionPathSlice.reduce(\n    (obj, path) => obj[path],\n    updatedRoute as any\n  ) as ExecutionAction\n  return action\n}\n\nexport const getSourceTxHash = (route?: RouteExtended): string | undefined => {\n  const sourceAction = route?.steps[0].execution?.actions\n    ?.filter(\n      (action) => !['RESET_ALLOWANCE', 'SET_ALLOWANCE'].includes(action.type)\n    )\n    .find((action) => action.txHash || action.taskId)\n  return sourceAction?.txHash || sourceAction?.taskId\n}\n"],"mappings":";;AAGA,MAAa,eAAe,UAAkC;CAC5D,OAAO,MAAM,MAAM,OAAO,SAAS,KAAK,WAAW,WAAW,MAAM;AACtE;AAEA,MAAa,wBAAwB,UAAkC;CACrE,OAAO,MAAM,MAAM,MAAM,SACvB,KAAK,WAAW,SAAS,MAAM,WAAW,OAAO,cAAc,SAAS,CAC1E;AACF;AAEA,MAAa,mBAAmB,UAAkC;CAChE,OAAO,MAAM,MAAM,MAAM,SACvB,KAAK,WAAW,SAAS,MAAM,WAAW,OAAO,cAAc,UAAU,CAC3E;AACF;AAEA,MAAa,iBAAiB,UAAkC;CAC9D,OAAO,MAAM,MAAM,MAAM,SAAS,KAAK,WAAW,WAAW,QAAQ;AACvE;AAEA,MAAa,iBAAiB,UAAmC;CAC/D,IAAI,CAAC,OACH,OAAO;CAET,MAAM,SAAS,YAAY,KAAK;CAChC,MAAM,WAAW,cAAc,KAAK;CACpC,MAAM,iBAAiB,MAAM,MAAM,MAAM,SAAS,KAAK,SAAS;CAChE,OAAO,CAAC,UAAU,CAAC,YAAY;AACjC;AAEA,MAAa,oBACX,cACA,iBACgC;CAChC,MAAM,aAAa,UAAU,cAAc,YAAY,EAAE,MAAM,SAC7D,KAAK,KAAK,SAAS,SAAS,CAC9B;CACA,IAAI,CAAC,YACH;CAIF,MAAM,kBAAkB,WAAW,KAAK,QAAQ,SAAS,IAAI;CAO7D,OANwB,WAAW,KAAK,MAAM,GAAG,eAEpB,EAAE,QAC5B,KAAK,SAAS,IAAI,OACnB,YAEU;AACd;AAEA,MAAa,mBAAmB,UAA8C;CAC5E,MAAM,eAAe,OAAO,MAAM,GAAG,WAAW,SAC5C,QACC,WAAW,CAAC,CAAC,mBAAmB,eAAe,EAAE,SAAS,OAAO,IAAI,CACxE,EACC,MAAM,WAAW,OAAO,UAAU,OAAO,MAAM;CAClD,OAAO,cAAc,UAAU,cAAc;AAC/C"}

package/dist/esm/stores/settings/SettingsStore.js

@@ -0,0 +1,26 @@
+import { createSettingsStore } from "./createSettingsStore.js";
+import { createContext, useContext, useRef } from "react";
+import { useShallow } from "zustand/shallow";
+import { jsx } from "react/jsx-runtime";
+//#region src/stores/settings/SettingsStore.tsx
+const SettingsStoreContext = createContext(null);
+const SettingsStoreProvider = ({ children, config }) => {
+	const storeRef = useRef(null);
+	if (!storeRef.current) storeRef.current = createSettingsStore(config);
+	return /* @__PURE__ */ jsx(SettingsStoreContext.Provider, {
+		value: storeRef.current,
+		children
+	});
+};
+function useSettingsStoreContext() {
+	const useStore = useContext(SettingsStoreContext);
+	if (!useStore) throw new Error("You forgot to wrap your component in SettingsStoreContext.");
+	return useStore;
+}
+function useSettingsStore(selector) {
+	return useSettingsStoreContext()(useShallow(selector));
+}
+//#endregion
+export { SettingsStoreProvider, useSettingsStore, useSettingsStoreContext };
+
+//# sourceMappingURL=SettingsStore.js.map

package/dist/esm/stores/settings/SettingsStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SettingsStore.js","names":[],"sources":["../../../../src/stores/settings/SettingsStore.tsx"],"sourcesContent":["import {\n  createContext,\n  type JSX,\n  type PropsWithChildren,\n  useContext,\n  useRef,\n} from 'react'\nimport type { StoreApi, UseBoundStore } from 'zustand'\nimport { useShallow } from 'zustand/shallow'\nimport { createSettingsStore } from './createSettingsStore.js'\nimport type { SettingsState, SettingsStoreProviderProps } from './types.js'\n\ntype SettingsStore = UseBoundStore<StoreApi<SettingsState>>\n\nconst SettingsStoreContext = createContext<SettingsStore | null>(null)\n\nexport const SettingsStoreProvider = ({\n  children,\n  config,\n}: PropsWithChildren<SettingsStoreProviderProps>): JSX.Element => {\n  const storeRef = useRef<SettingsStore>(null)\n  if (!storeRef.current) {\n    storeRef.current = createSettingsStore(config)\n  }\n  return (\n    <SettingsStoreContext.Provider value={storeRef.current}>\n      {children}\n    </SettingsStoreContext.Provider>\n  )\n}\n\nexport function useSettingsStoreContext(): any {\n  const useStore = useContext(SettingsStoreContext)\n  if (!useStore) {\n    throw new Error(\n      'You forgot to wrap your component in SettingsStoreContext.'\n    )\n  }\n  return useStore\n}\n\nexport function useSettingsStore<T>(selector: (state: SettingsState) => T): T {\n  const useStore = useSettingsStoreContext()\n  return useStore(useShallow(selector))\n}\n"],"mappings":";;;;;AAcA,MAAM,uBAAuB,cAAoC,IAAI;AAErE,MAAa,yBAAyB,EACpC,UACA,aACgE;CAChE,MAAM,WAAW,OAAsB,IAAI;CAC3C,IAAI,CAAC,SAAS,SACZ,SAAS,UAAU,oBAAoB,MAAM;CAE/C,OACE,oBAAC,qBAAqB,UAAtB;EAA+B,OAAO,SAAS;EAC5C;CAC4B,CAAA;AAEnC;AAEA,SAAgB,0BAA+B;CAC7C,MAAM,WAAW,WAAW,oBAAoB;CAChD,IAAI,CAAC,UACH,MAAM,IAAI,MACR,4DACF;CAEF,OAAO;AACT;AAEA,SAAgB,iBAAoB,UAA0C;CAE5E,OADiB,wBACH,EAAE,WAAW,QAAQ,CAAC;AACtC"}

package/dist/esm/stores/settings/createSettingsStore.js

@@ -0,0 +1,126 @@
+import { allLanguages } from "../../providers/I18nProvider/constants.js";
+import { loadLocale } from "../../providers/I18nProvider/i18n.js";
+import { SettingsToolTypes } from "./types.js";
+import { getStateValues } from "./utils/getStateValues.js";
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+const defaultConfigurableSettings = {
+	routePriority: "CHEAPEST",
+	slippage: void 0,
+	gasPrice: "normal"
+};
+const defaultSettings = {
+	gasPrice: "normal",
+	enabledAutoRefuel: true,
+	disabledBridges: [],
+	disabledExchanges: [],
+	enabledBridges: [],
+	enabledExchanges: [],
+	_enabledBridges: {},
+	_enabledExchanges: {},
+	smallBalanceThreshold: void 0
+};
+const createSettingsStore = (config) => create()(persist((set, get) => ({
+	...defaultSettings,
+	setValue: (key, value) => set(() => ({ [key]: value })),
+	setValues: (values) => set(() => ({ ...values })),
+	getSettings: () => getStateValues(get()),
+	getValue: (key) => get()[key],
+	initializeTools: (toolType, tools, reset) => {
+		if (!tools.length) return;
+		set((state) => {
+			const updatedState = { ...state };
+			if (!reset) {
+				tools.forEach((tool) => {
+					if (!Object.hasOwn(updatedState[`_enabled${toolType}`], tool)) updatedState[`_enabled${toolType}`][tool] = true;
+				});
+				updatedState[`_enabled${toolType}`] = Object.fromEntries(Object.entries(updatedState[`_enabled${toolType}`]).filter(([key]) => tools.includes(key)));
+			} else tools.forEach((tool) => {
+				updatedState[`_enabled${toolType}`][tool] = true;
+			});
+			const enabledToolKeys = Object.keys(updatedState[`_enabled${toolType}`]);
+			updatedState[`enabled${toolType}`] = enabledToolKeys.filter((key) => updatedState[`_enabled${toolType}`][key]);
+			updatedState[`disabled${toolType}`] = enabledToolKeys.filter((key) => !updatedState[`_enabled${toolType}`][key]);
+			return updatedState;
+		});
+	},
+	setToolValue: (toolType, tool, value) => set((state) => {
+		const enabledTools = {
+			...state[`_enabled${toolType}`],
+			[tool]: value
+		};
+		const enabledToolKeys = Object.keys(enabledTools);
+		return {
+			[`_enabled${toolType}`]: enabledTools,
+			[`enabled${toolType}`]: enabledToolKeys.filter((key) => enabledTools[key]),
+			[`disabled${toolType}`]: enabledToolKeys.filter((key) => !enabledTools[key])
+		};
+	}),
+	toggleToolKeys: (toolType, toolKeys) => set((state) => {
+		const allKeysInCollectionEnabled = toolKeys.every((toolKey) => state[`_enabled${toolType}`][toolKey]);
+		const updatedTools = toolKeys.reduce((accum, toolKey) => {
+			accum[toolKey] = !allKeysInCollectionEnabled;
+			return accum;
+		}, { ...state[`_enabled${toolType}`] });
+		const enableKeys = [];
+		const disabledKeys = [];
+		Object.entries(updatedTools).forEach(([key, value]) => {
+			if (value) enableKeys.push(key);
+			else disabledKeys.push(key);
+		});
+		return {
+			[`_enabled${toolType}`]: updatedTools,
+			[`enabled${toolType}`]: enableKeys,
+			[`disabled${toolType}`]: disabledKeys
+		};
+	}),
+	reset: (bridges, exchanges) => {
+		set(() => ({
+			...defaultSettings,
+			...defaultConfigurableSettings
+		}));
+		get().initializeTools("Bridges", bridges, true);
+		get().initializeTools("Exchanges", exchanges, true);
+		return { ...get() };
+	}
+}), {
+	name: "li.fi-widget-settings",
+	version: 6,
+	partialize: (state) => {
+		const { disabledBridges, disabledExchanges, enabledBridges, enabledExchanges, ...partializedState } = state;
+		return partializedState;
+	},
+	merge: (persistedState, currentState) => {
+		const state = {
+			...currentState,
+			...persistedState
+		};
+		SettingsToolTypes.forEach((toolType) => {
+			if (persistedState?.[`_enabled${toolType}`]) {
+				const enabledToolKeys = Object.keys(persistedState[`_enabled${toolType}`]);
+				state[`enabled${toolType}`] = enabledToolKeys.filter((key) => persistedState[`_enabled${toolType}`][key]);
+				state[`disabled${toolType}`] = enabledToolKeys.filter((key) => !persistedState[`_enabled${toolType}`][key]);
+			}
+		});
+		return state;
+	},
+	migrate: () => ({}),
+	onRehydrateStorage: () => {
+		const initializeLanguageSettings = async (state, initialLanguage) => {
+			const customLanguages = Object.keys(config?.languageResources || {}).filter((key) => !allLanguages.includes(key));
+			if (initialLanguage && initialLanguage !== "en" && !customLanguages.includes(initialLanguage)) await loadLocale(initialLanguage, config?.languageResources?.[initialLanguage]).then((languageResource) => {
+				state.setValues({
+					language: initialLanguage,
+					languageCache: languageResource
+				});
+			});
+		};
+		return (state) => {
+			if (state) initializeLanguageSettings(state, state.getValue("language") || config?.languages?.default);
+		};
+	}
+}));
+//#endregion
+export { createSettingsStore, defaultConfigurableSettings };
+
+//# sourceMappingURL=createSettingsStore.js.map

package/dist/esm/stores/settings/createSettingsStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSettingsStore.js","names":[],"sources":["../../../../src/stores/settings/createSettingsStore.ts"],"sourcesContent":["/** biome-ignore-all lint/correctness/noUnusedVariables: allowed in this store */\nimport type { StoreApi, UseBoundStore } from 'zustand'\nimport { create } from 'zustand'\nimport { persist } from 'zustand/middleware'\nimport { allLanguages } from '../../providers/I18nProvider/constants.js'\nimport { loadLocale } from '../../providers/I18nProvider/i18n.js'\nimport type { LanguageKey } from '../../providers/I18nProvider/types.js'\nimport type { WidgetConfig } from '../../types/widget.js'\nimport type { SettingsProps, SettingsState } from './types.js'\nimport { SettingsToolTypes } from './types.js'\nimport { getStateValues } from './utils/getStateValues.js'\n\nexport const defaultSlippage = undefined\n\nexport const defaultConfigurableSettings: Pick<\n  SettingsState,\n  'routePriority' | 'slippage' | 'gasPrice'\n> = {\n  routePriority: 'CHEAPEST',\n  slippage: defaultSlippage,\n  gasPrice: 'normal',\n}\n\nconst defaultSettings: SettingsProps = {\n  gasPrice: 'normal',\n  enabledAutoRefuel: true,\n  disabledBridges: [],\n  disabledExchanges: [],\n  enabledBridges: [],\n  enabledExchanges: [],\n  _enabledBridges: {},\n  _enabledExchanges: {},\n  smallBalanceThreshold: undefined,\n}\n\nexport const createSettingsStore = (\n  config: WidgetConfig\n): UseBoundStore<StoreApi<SettingsState>> =>\n  create<SettingsState>()(\n    persist(\n      (set, get) => ({\n        ...defaultSettings,\n        setValue: (key, value) =>\n          set(() => ({\n            [key]: value,\n          })),\n        setValues: (values: Partial<SettingsProps>) =>\n          set(() => ({\n            ...values,\n          })),\n        getSettings: () => getStateValues(get()),\n        getValue: (key) => get()[key],\n        initializeTools: (toolType, tools, reset) => {\n          if (!tools.length) {\n            return\n          }\n          set((state) => {\n            const updatedState = { ...state }\n            if (!reset) {\n              // Add new tools\n              tools.forEach((tool) => {\n                if (!Object.hasOwn(updatedState[`_enabled${toolType}`], tool)) {\n                  updatedState[`_enabled${toolType}`][tool] = true\n                }\n              })\n              // Filter tools we no longer have\n              updatedState[`_enabled${toolType}`] = Object.fromEntries(\n                Object.entries(updatedState[`_enabled${toolType}`]).filter(\n                  ([key]) => tools.includes(key)\n                )\n              )\n            } else {\n              tools.forEach((tool) => {\n                updatedState[`_enabled${toolType}`][tool] = true\n              })\n            }\n            const enabledToolKeys = Object.keys(\n              updatedState[`_enabled${toolType}`]\n            )\n            updatedState[`enabled${toolType}`] = enabledToolKeys.filter(\n              (key) => updatedState[`_enabled${toolType}`][key]\n            )\n            updatedState[`disabled${toolType}`] = enabledToolKeys.filter(\n              (key) => !updatedState[`_enabled${toolType}`][key]\n            )\n            return updatedState\n          })\n        },\n        setToolValue: (toolType, tool, value) =>\n          set((state) => {\n            const enabledTools = {\n              ...state[`_enabled${toolType}`],\n              [tool]: value,\n            }\n            const enabledToolKeys = Object.keys(enabledTools)\n            return {\n              [`_enabled${toolType}`]: enabledTools,\n              [`enabled${toolType}`]: enabledToolKeys.filter(\n                (key) => enabledTools[key]\n              ),\n              [`disabled${toolType}`]: enabledToolKeys.filter(\n                (key) => !enabledTools[key]\n              ),\n            }\n          }),\n        toggleToolKeys: (toolType, toolKeys) =>\n          set((state) => {\n            const allKeysInCollectionEnabled = toolKeys.every(\n              (toolKey) => state[`_enabled${toolType}`][toolKey]\n            )\n\n            // then toggle those keys to false\n            const updatedTools = toolKeys.reduce(\n              (accum, toolKey) => {\n                accum[toolKey] = !allKeysInCollectionEnabled\n                return accum\n              },\n              {\n                ...state[`_enabled${toolType}`],\n              }\n            )\n\n            const enableKeys: string[] = []\n            const disabledKeys: string[] = []\n\n            Object.entries(updatedTools).forEach(([key, value]) => {\n              if (value) {\n                enableKeys.push(key)\n              } else {\n                disabledKeys.push(key)\n              }\n            })\n\n            return {\n              [`_enabled${toolType}`]: updatedTools,\n              [`enabled${toolType}`]: enableKeys,\n              [`disabled${toolType}`]: disabledKeys,\n            }\n          }),\n        reset: (bridges, exchanges) => {\n          set(() => ({\n            ...defaultSettings,\n            ...defaultConfigurableSettings,\n          }))\n          get().initializeTools('Bridges', bridges, true)\n          get().initializeTools('Exchanges', exchanges, true)\n          return { ...get() }\n        },\n      }),\n      {\n        name: 'li.fi-widget-settings',\n        version: 6,\n        partialize: (state) => {\n          const {\n            disabledBridges,\n            disabledExchanges,\n            enabledBridges,\n            enabledExchanges,\n            ...partializedState\n          } = state\n          return partializedState\n        },\n        merge: (persistedState: any, currentState: SettingsState) => {\n          const state = { ...currentState, ...persistedState }\n          SettingsToolTypes.forEach((toolType) => {\n            if (persistedState?.[`_enabled${toolType}`]) {\n              const enabledToolKeys = Object.keys(\n                persistedState[`_enabled${toolType}`]\n              )\n              state[`enabled${toolType}`] = enabledToolKeys.filter(\n                (key) => persistedState[`_enabled${toolType}`][key]\n              )\n              state[`disabled${toolType}`] = enabledToolKeys.filter(\n                (key) => !persistedState[`_enabled${toolType}`][key]\n              )\n            }\n          })\n          return state\n        },\n        migrate: () => ({}),\n        onRehydrateStorage: () => {\n          const initializeLanguageSettings = async (\n            state: SettingsState,\n            initialLanguage?: string\n          ) => {\n            const customLanguages = Object.keys(\n              config?.languageResources || {}\n            ).filter((key) => !allLanguages.includes(key as LanguageKey))\n            if (\n              initialLanguage &&\n              // Custom language resources and English are added statically.\n              initialLanguage !== 'en' &&\n              !customLanguages.includes(initialLanguage)\n            ) {\n              await loadLocale(\n                initialLanguage as LanguageKey,\n                config?.languageResources?.[initialLanguage as LanguageKey]\n              ).then((languageResource) => {\n                state.setValues({\n                  language: initialLanguage,\n                  languageCache: languageResource,\n                })\n              })\n            }\n          }\n          return (state?: SettingsState) => {\n            // Preload translations (from existing translation files)\n            if (state) {\n              // NB: State always exists unless there is any error\n              initializeLanguageSettings(\n                state,\n                state.getValue('language') || config?.languages?.default\n              )\n            }\n          }\n        },\n      }\n    )\n  )\n"],"mappings":"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"}

package/dist/esm/stores/settings/types.d.ts

@@ -0,0 +1,25 @@
+import { LanguageResource } from "../../providers/I18nProvider/types.js";
+import { Order } from "@lifi/sdk";
+import { PropsWithChildren } from "react";
+import { StoreApi, UseBoundStore } from "zustand";
+
+//#region src/stores/settings/types.d.ts
+interface SettingsProps {
+  gasPrice?: string;
+  language?: string;
+  languageCache?: LanguageResource;
+  lastDefaultLanguage?: string;
+  routePriority?: Order;
+  enabledAutoRefuel: boolean;
+  slippage?: string;
+  disabledBridges: string[];
+  enabledBridges: string[];
+  _enabledBridges: Record<string, boolean>;
+  disabledExchanges: string[];
+  enabledExchanges: string[];
+  _enabledExchanges: Record<string, boolean>;
+  smallBalanceThreshold?: string;
+}
+//#endregion
+export { SettingsProps };
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/stores/settings/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../../src/stores/settings/types.ts"],"mappings":";;;;;;UAgBiB,aAAA;EACf,QAAA;EACA,QAAA;EACA,aAAA,GAAgB,gBAAA;EAChB,mBAAA;EACA,aAAA,GAAgB,KAAA;EAChB,iBAAA;EACA,QAAA;EACA,eAAA;EACA,cAAA;EACA,eAAA,EAAiB,MAAA;EACjB,iBAAA;EACA,gBAAA;EACA,iBAAA,EAAmB,MAAA;EACnB,qBAAA;AAAA"}

package/dist/esm/stores/settings/types.js

@@ -0,0 +1,6 @@
+//#region src/stores/settings/types.ts
+const SettingsToolTypes = ["Bridges", "Exchanges"];
+//#endregion
+export { SettingsToolTypes };
+
+//# sourceMappingURL=types.js.map

package/dist/esm/stores/settings/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../../src/stores/settings/types.ts"],"sourcesContent":["import type { Order } from '@lifi/sdk'\nimport type { PropsWithChildren } from 'react'\nimport type { StoreApi, UseBoundStore } from 'zustand'\nimport type { LanguageResource } from '../../providers/I18nProvider/types.js'\nimport type { SplitMode, WidgetConfig } from '../../types/widget.js'\n\nexport type ValueSetter<S> = <K extends keyof S>(\n  key: K,\n  value: S[Extract<K, string>]\n) => void\n\ntype ValueGetter<S> = <K extends keyof S>(key: K) => S[K]\n\nexport const SettingsToolTypes = ['Bridges', 'Exchanges'] as const\nexport type SettingsToolType = (typeof SettingsToolTypes)[number]\n\nexport interface SettingsProps {\n  gasPrice?: string\n  language?: string\n  languageCache?: LanguageResource\n  lastDefaultLanguage?: string\n  routePriority?: Order\n  enabledAutoRefuel: boolean\n  slippage?: string\n  disabledBridges: string[]\n  enabledBridges: string[]\n  _enabledBridges: Record<string, boolean>\n  disabledExchanges: string[]\n  enabledExchanges: string[]\n  _enabledExchanges: Record<string, boolean>\n  smallBalanceThreshold?: string\n}\n\nexport interface SettingsActions {\n  setValue: ValueSetter<SettingsProps>\n  setValues: (values: Partial<SettingsProps>) => void\n  getValue: ValueGetter<SettingsProps>\n  getSettings: () => SettingsProps\n  initializeTools(\n    toolType: SettingsToolType,\n    tools: string[],\n    reset?: boolean\n  ): void\n  setToolValue(toolType: SettingsToolType, tool: string, value: boolean): void\n  toggleToolKeys(toolType: SettingsToolType, toolKeys: string[]): void\n  reset(bridges: string[], exchanges: string[]): void\n}\n\nexport type SettingsState = SettingsProps & SettingsActions\n\nexport interface SplitModeState {\n  state?: SplitMode\n  setState(state: SplitMode): void\n}\n\nexport type SplitModeStore = UseBoundStore<StoreApi<SplitModeState>>\n\nexport interface SplitModeProps {\n  state?: SplitMode\n}\n\nexport type SplitModeProviderProps = PropsWithChildren<SplitModeProps>\n\nexport interface SettingsStoreProviderProps {\n  config: WidgetConfig\n}\n"],"mappings":";AAaA,MAAa,oBAAoB,CAAC,WAAW,WAAW"}

package/dist/esm/stores/settings/useSettings.js

@@ -0,0 +1,12 @@
+import { useSettingsStore } from "./SettingsStore.js";
+//#region src/stores/settings/useSettings.ts
+const useSettings = (keys) => {
+	return useSettingsStore((state) => keys.reduce((values, key) => {
+		values[key] = state[key];
+		return values;
+	}, {}));
+};
+//#endregion
+export { useSettings };
+
+//# sourceMappingURL=useSettings.js.map

package/dist/esm/stores/settings/useSettings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSettings.js","names":[],"sources":["../../../../src/stores/settings/useSettings.ts"],"sourcesContent":["import { useSettingsStore } from './SettingsStore.js'\nimport type { SettingsState } from './types.js'\n\nexport const useSettings = <K extends keyof SettingsState>(\n  keys: Array<K>\n): Pick<SettingsState, (typeof keys)[number]> => {\n  return useSettingsStore((state) =>\n    keys.reduce(\n      (values, key) => {\n        values[key] = state[key]\n        return values\n      },\n      {} as Pick<SettingsState, (typeof keys)[number]>\n    )\n  )\n}\n"],"mappings":";;AAGA,MAAa,eACX,SAC+C;CAC/C,OAAO,kBAAkB,UACvB,KAAK,QACF,QAAQ,QAAQ;EACf,OAAO,OAAO,MAAM;EACpB,OAAO;CACT,GACA,CAAC,CACH,CACF;AACF"}

package/dist/esm/stores/settings/useSettingsActions.js

@@ -0,0 +1,70 @@
+import { useWidgetEvents } from "../../hooks/useWidgetEvents.js";
+import "../../types/events.js";
+import { deepEqual } from "../../utils/deepEqual.js";
+import { defaultConfigurableSettings } from "./createSettingsStore.js";
+import { useSettingsStore } from "./SettingsStore.js";
+import { useCallback } from "react";
+//#region src/stores/settings/useSettingsActions.ts
+const emitEventOnChange = (emitter, actions, settingFunction, ...args) => {
+	const oldSettings = actions.getSettings();
+	settingFunction(...args);
+	const newSettings = actions.getSettings();
+	if (!deepEqual(oldSettings, newSettings)) Object.keys(oldSettings).forEach((toolKey) => {
+		if (!deepEqual(oldSettings[toolKey], newSettings[toolKey])) emitter.emit("settingUpdated", {
+			setting: toolKey,
+			newValue: newSettings[toolKey],
+			oldValue: oldSettings[toolKey],
+			newSettings,
+			oldSettings
+		});
+	});
+};
+const useSettingsActions = () => {
+	const emitter = useWidgetEvents();
+	const actions = useSettingsStore((state) => ({
+		setValue: state.setValue,
+		setValues: state.setValues,
+		getValue: state.getValue,
+		getSettings: state.getSettings,
+		reset: state.reset,
+		setToolValue: state.setToolValue,
+		toggleToolKeys: state.toggleToolKeys
+	}));
+	const setValueWithEmittedEvent = useCallback((value, newValue) => {
+		const setting = value;
+		emitEventOnChange(emitter, actions, actions.setValue, setting, newValue);
+	}, [emitter, actions]);
+	return {
+		setValue: setValueWithEmittedEvent,
+		setValues: useCallback((values) => {
+			Object.entries(values).forEach(([key, value]) => {
+				setValueWithEmittedEvent(key, value);
+			});
+		}, [setValueWithEmittedEvent]),
+		setDefaultSettings: useCallback((config) => {
+			const slippage = actions.getValue("slippage");
+			const routePriority = actions.getValue("routePriority");
+			const gasPrice = actions.getValue("gasPrice");
+			const defaultSlippage = (config?.slippage || 0) * 100;
+			const defaultRoutePriority = config?.routePriority;
+			defaultConfigurableSettings.slippage = (defaultSlippage || defaultConfigurableSettings.slippage)?.toString();
+			defaultConfigurableSettings.routePriority = defaultRoutePriority || defaultConfigurableSettings.routePriority;
+			if (!slippage) setValueWithEmittedEvent("slippage", defaultConfigurableSettings.slippage);
+			if (!routePriority) setValueWithEmittedEvent("routePriority", defaultConfigurableSettings.routePriority);
+			if (!gasPrice) setValueWithEmittedEvent("gasPrice", defaultConfigurableSettings.gasPrice);
+		}, [actions, setValueWithEmittedEvent]),
+		resetSettings: useCallback((bridges, exchanges) => {
+			emitEventOnChange(emitter, actions, actions.reset, bridges, exchanges);
+		}, [emitter, actions]),
+		setToolValue: useCallback((toolType, tool, value) => {
+			emitEventOnChange(emitter, actions, actions.setToolValue, toolType, tool, value);
+		}, [emitter, actions]),
+		toggleToolKeys: useCallback((toolType, toolKeys) => {
+			emitEventOnChange(emitter, actions, actions.toggleToolKeys, toolType, toolKeys);
+		}, [emitter, actions])
+	};
+};
+//#endregion
+export { useSettingsActions };
+
+//# sourceMappingURL=useSettingsActions.js.map

package/dist/esm/stores/settings/useSettingsActions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSettingsActions.js","names":[],"sources":["../../../../src/stores/settings/useSettingsActions.ts"],"sourcesContent":["import { useCallback } from 'react'\nimport type { widgetEvents } from '../../hooks/useWidgetEvents.js'\nimport { useWidgetEvents } from '../../hooks/useWidgetEvents.js'\nimport { WidgetEvent } from '../../types/events.js'\nimport type { WidgetConfig } from '../../types/widget.js'\nimport { deepEqual } from '../../utils/deepEqual.js'\nimport { defaultConfigurableSettings } from './createSettingsStore.js'\nimport { useSettingsStore } from './SettingsStore.js'\nimport type {\n  SettingsActions,\n  SettingsProps,\n  SettingsToolType,\n  ValueSetter,\n} from './types.js'\n\nconst emitEventOnChange = <T extends (...args: any[]) => any>(\n  emitter: typeof widgetEvents,\n  actions: Omit<SettingsActions, 'initializeTools'>,\n  settingFunction: T,\n  ...args: Parameters<T>\n) => {\n  const oldSettings = actions.getSettings()\n\n  settingFunction(...args)\n\n  const newSettings = actions.getSettings()\n\n  if (!deepEqual(oldSettings, newSettings)) {\n    ;(Object.keys(oldSettings) as (keyof SettingsProps)[]).forEach(\n      (toolKey) => {\n        if (!deepEqual(oldSettings[toolKey], newSettings[toolKey])) {\n          emitter.emit(WidgetEvent.SettingUpdated, {\n            setting: toolKey,\n            newValue: newSettings[toolKey],\n            oldValue: oldSettings[toolKey],\n            newSettings: newSettings,\n            oldSettings: oldSettings,\n          })\n        }\n      }\n    )\n  }\n}\n\nexport const useSettingsActions = (): {\n  setValue: ValueSetter<SettingsProps>\n  setValues: (values: Partial<SettingsProps>) => void\n  setDefaultSettings: (config?: WidgetConfig) => void\n  resetSettings: (bridges: string[], exchanges: string[]) => void\n  setToolValue: (\n    toolType: SettingsToolType,\n    tool: string,\n    value: boolean\n  ) => void\n  toggleToolKeys: (toolType: SettingsToolType, toolKeys: string[]) => void\n} => {\n  const emitter = useWidgetEvents()\n  const actions = useSettingsStore((state) => ({\n    setValue: state.setValue,\n    setValues: state.setValues,\n    getValue: state.getValue,\n    getSettings: state.getSettings,\n    reset: state.reset,\n    setToolValue: state.setToolValue,\n    toggleToolKeys: state.toggleToolKeys,\n  }))\n\n  const setValueWithEmittedEvent = useCallback<ValueSetter<SettingsProps>>(\n    (value, newValue) => {\n      const setting = value as keyof SettingsProps\n      emitEventOnChange(emitter, actions, actions.setValue, setting, newValue)\n    },\n    [emitter, actions]\n  )\n\n  const setValuesWithEmittedEvent = useCallback(\n    (values: Partial<SettingsProps>) => {\n      Object.entries(values).forEach(([key, value]) => {\n        setValueWithEmittedEvent(key as keyof SettingsProps, value)\n      })\n    },\n    [setValueWithEmittedEvent]\n  )\n\n  const setDefaultSettingsWithEmittedEvents = useCallback(\n    (config?: WidgetConfig) => {\n      const slippage = actions.getValue('slippage')\n      const routePriority = actions.getValue('routePriority')\n      const gasPrice = actions.getValue('gasPrice')\n\n      const defaultSlippage = (config?.slippage || 0) * 100\n      const defaultRoutePriority = config?.routePriority\n\n      defaultConfigurableSettings.slippage = (\n        defaultSlippage || defaultConfigurableSettings.slippage\n      )?.toString()\n\n      defaultConfigurableSettings.routePriority =\n        defaultRoutePriority || defaultConfigurableSettings.routePriority\n\n      if (!slippage) {\n        setValueWithEmittedEvent(\n          'slippage',\n          defaultConfigurableSettings.slippage\n        )\n      }\n      if (!routePriority) {\n        setValueWithEmittedEvent(\n          'routePriority',\n          defaultConfigurableSettings.routePriority\n        )\n      }\n      if (!gasPrice) {\n        setValueWithEmittedEvent(\n          'gasPrice',\n          defaultConfigurableSettings.gasPrice\n        )\n      }\n    },\n    [actions, setValueWithEmittedEvent]\n  )\n\n  const resetWithEmittedEvents = useCallback(\n    (bridges: string[], exchanges: string[]) => {\n      emitEventOnChange(emitter, actions, actions.reset, bridges, exchanges)\n    },\n    [emitter, actions]\n  )\n\n  const setToolValueWithEmittedEvents = useCallback(\n    (toolType: SettingsToolType, tool: string, value: boolean) => {\n      emitEventOnChange(\n        emitter,\n        actions,\n        actions.setToolValue,\n        toolType,\n        tool,\n        value\n      )\n    },\n    [emitter, actions]\n  )\n\n  const toggleToolKeysWithEmittedEvents = useCallback(\n    (toolType: SettingsToolType, toolKeys: string[]) => {\n      emitEventOnChange(\n        emitter,\n        actions,\n        actions.toggleToolKeys,\n        toolType,\n        toolKeys\n      )\n    },\n    [emitter, actions]\n  )\n\n  return {\n    setValue: setValueWithEmittedEvent,\n    setValues: setValuesWithEmittedEvent,\n    setDefaultSettings: setDefaultSettingsWithEmittedEvents,\n    resetSettings: resetWithEmittedEvents,\n    setToolValue: setToolValueWithEmittedEvents,\n    toggleToolKeys: toggleToolKeysWithEmittedEvents,\n  }\n}\n"],"mappings":";;;;;;;AAeA,MAAM,qBACJ,SACA,SACA,iBACA,GAAG,SACA;CACH,MAAM,cAAc,QAAQ,YAAY;CAExC,gBAAgB,GAAG,IAAI;CAEvB,MAAM,cAAc,QAAQ,YAAY;CAExC,IAAI,CAAC,UAAU,aAAa,WAAW,GACpC,OAAQ,KAAK,WAAW,EAA8B,SACpD,YAAY;EACX,IAAI,CAAC,UAAU,YAAY,UAAU,YAAY,QAAQ,GACvD,QAAQ,KAAA,kBAAiC;GACvC,SAAS;GACT,UAAU,YAAY;GACtB,UAAU,YAAY;GACT;GACA;EACf,CAAC;CAEL,CACF;AAEJ;AAEA,MAAa,2BAWR;CACH,MAAM,UAAU,gBAAgB;CAChC,MAAM,UAAU,kBAAkB,WAAW;EAC3C,UAAU,MAAM;EAChB,WAAW,MAAM;EACjB,UAAU,MAAM;EAChB,aAAa,MAAM;EACnB,OAAO,MAAM;EACb,cAAc,MAAM;EACpB,gBAAgB,MAAM;CACxB,EAAE;CAEF,MAAM,2BAA2B,aAC9B,OAAO,aAAa;EACnB,MAAM,UAAU;EAChB,kBAAkB,SAAS,SAAS,QAAQ,UAAU,SAAS,QAAQ;CACzE,GACA,CAAC,SAAS,OAAO,CACnB;CAmFA,OAAO;EACL,UAAU;EACV,WAnFgC,aAC/B,WAAmC;GAClC,OAAO,QAAQ,MAAM,EAAE,SAAS,CAAC,KAAK,WAAW;IAC/C,yBAAyB,KAA4B,KAAK;GAC5D,CAAC;EACH,GACA,CAAC,wBAAwB,CA6EU;EACnC,oBA3E0C,aACzC,WAA0B;GACzB,MAAM,WAAW,QAAQ,SAAS,UAAU;GAC5C,MAAM,gBAAgB,QAAQ,SAAS,eAAe;GACtD,MAAM,WAAW,QAAQ,SAAS,UAAU;GAE5C,MAAM,mBAAmB,QAAQ,YAAY,KAAK;GAClD,MAAM,uBAAuB,QAAQ;GAErC,4BAA4B,YAC1B,mBAAmB,4BAA4B,WAC9C,SAAS;GAEZ,4BAA4B,gBAC1B,wBAAwB,4BAA4B;GAEtD,IAAI,CAAC,UACH,yBACE,YACA,4BAA4B,QAC9B;GAEF,IAAI,CAAC,eACH,yBACE,iBACA,4BAA4B,aAC9B;GAEF,IAAI,CAAC,UACH,yBACE,YACA,4BAA4B,QAC9B;EAEJ,GACA,CAAC,SAAS,wBAAwB,CAwCoB;EACtD,eAtC6B,aAC5B,SAAmB,cAAwB;GAC1C,kBAAkB,SAAS,SAAS,QAAQ,OAAO,SAAS,SAAS;EACvE,GACA,CAAC,SAAS,OAAO,CAkCmB;EACpC,cAhCoC,aACnC,UAA4B,MAAc,UAAmB;GAC5D,kBACE,SACA,SACA,QAAQ,cACR,UACA,MACA,KACF;EACF,GACA,CAAC,SAAS,OAAO,CAqByB;EAC1C,gBAnBsC,aACrC,UAA4B,aAAuB;GAClD,kBACE,SACA,SACA,QAAQ,gBACR,UACA,QACF;EACF,GACA,CAAC,SAAS,OAAO,CAS6B;CAChD;AACF"}

package/dist/esm/stores/settings/useSplitModeStore.js

@@ -0,0 +1,36 @@
+import { createContext, useContext, useRef } from "react";
+import { create } from "zustand";
+import { useShallow } from "zustand/shallow";
+import { jsx } from "react/jsx-runtime";
+//#region src/stores/settings/useSplitModeStore.tsx
+const SplitModeStoreContext = createContext(null);
+const shouldRecreateStore = (store, props) => {
+	const { state } = store.getState();
+	return state !== props.state;
+};
+function SplitModeStoreProvider({ children, ...props }) {
+	const storeRef = useRef(null);
+	if (!storeRef.current || shouldRecreateStore(storeRef.current, props)) storeRef.current = createSplitModeStore(props);
+	return /* @__PURE__ */ jsx(SplitModeStoreContext.Provider, {
+		value: storeRef.current,
+		children
+	});
+}
+function useSplitModeStoreContext() {
+	const useStore = useContext(SplitModeStoreContext);
+	if (!useStore) throw new Error(`You forgot to wrap your component in <${SplitModeStoreProvider.name}>.`);
+	return useStore;
+}
+function useSplitModeStore(selector) {
+	return useSplitModeStoreContext()(useShallow(selector));
+}
+const createSplitModeStore = ({ state }) => create((set) => ({
+	state,
+	setState(state) {
+		set(() => ({ state }));
+	}
+}));
+//#endregion
+export { SplitModeStoreProvider, useSplitModeStore };
+
+//# sourceMappingURL=useSplitModeStore.js.map

package/dist/esm/stores/settings/useSplitModeStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSplitModeStore.js","names":[],"sources":["../../../../src/stores/settings/useSplitModeStore.tsx"],"sourcesContent":["import { createContext, type JSX, useContext, useRef } from 'react'\nimport { create } from 'zustand'\nimport { useShallow } from 'zustand/shallow'\nimport type {\n  SplitModeProps,\n  SplitModeProviderProps,\n  SplitModeState,\n  SplitModeStore,\n} from './types.js'\n\nconst SplitModeStoreContext = createContext<SplitModeStore | null>(null)\n\nconst shouldRecreateStore = (store: SplitModeStore, props: SplitModeProps) => {\n  const { state } = store.getState()\n  return state !== props.state\n}\n\nexport function SplitModeStoreProvider({\n  children,\n  ...props\n}: SplitModeProviderProps): JSX.Element {\n  const storeRef = useRef<SplitModeStore>(null)\n  if (!storeRef.current || shouldRecreateStore(storeRef.current, props)) {\n    storeRef.current = createSplitModeStore(props)\n  }\n  return (\n    <SplitModeStoreContext.Provider value={storeRef.current}>\n      {children}\n    </SplitModeStoreContext.Provider>\n  )\n}\n\nfunction useSplitModeStoreContext() {\n  const useStore = useContext(SplitModeStoreContext)\n  if (!useStore) {\n    throw new Error(\n      `You forgot to wrap your component in <${SplitModeStoreProvider.name}>.`\n    )\n  }\n  return useStore\n}\n\nexport function useSplitModeStore<T>(\n  selector: (state: SplitModeState) => T\n): T {\n  const useStore = useSplitModeStoreContext()\n  return useStore(useShallow(selector))\n}\n\nconst createSplitModeStore = ({ state }: SplitModeProps) =>\n  create<SplitModeState>((set) => ({\n    state,\n    setState(state) {\n      set(() => ({\n        state,\n      }))\n    },\n  }))\n"],"mappings":";;;;;AAUA,MAAM,wBAAwB,cAAqC,IAAI;AAEvE,MAAM,uBAAuB,OAAuB,UAA0B;CAC5E,MAAM,EAAE,UAAU,MAAM,SAAS;CACjC,OAAO,UAAU,MAAM;AACzB;AAEA,SAAgB,uBAAuB,EACrC,UACA,GAAG,SACmC;CACtC,MAAM,WAAW,OAAuB,IAAI;CAC5C,IAAI,CAAC,SAAS,WAAW,oBAAoB,SAAS,SAAS,KAAK,GAClE,SAAS,UAAU,qBAAqB,KAAK;CAE/C,OACE,oBAAC,sBAAsB,UAAvB;EAAgC,OAAO,SAAS;EAC7C;CAC6B,CAAA;AAEpC;AAEA,SAAS,2BAA2B;CAClC,MAAM,WAAW,WAAW,qBAAqB;CACjD,IAAI,CAAC,UACH,MAAM,IAAI,MACR,yCAAyC,uBAAuB,KAAK,GACvE;CAEF,OAAO;AACT;AAEA,SAAgB,kBACd,UACG;CAEH,OADiB,yBACH,EAAE,WAAW,QAAQ,CAAC;AACtC;AAEA,MAAM,wBAAwB,EAAE,YAC9B,QAAwB,SAAS;CAC/B;CACA,SAAS,OAAO;EACd,WAAW,EACT,MACF,EAAE;CACJ;AACF,EAAE"}

package/dist/esm/stores/settings/utils/getStateValues.js

@@ -0,0 +1,20 @@
+//#region src/stores/settings/utils/getStateValues.ts
+const getStateValues = (state) => ({
+	gasPrice: state.gasPrice,
+	language: state.language,
+	languageCache: state.languageCache,
+	lastDefaultLanguage: state.lastDefaultLanguage,
+	routePriority: state.routePriority,
+	enabledAutoRefuel: state.enabledAutoRefuel,
+	slippage: state.slippage,
+	disabledBridges: [...state.disabledBridges],
+	enabledBridges: [...state.enabledBridges],
+	_enabledBridges: { ...state._enabledBridges },
+	disabledExchanges: [...state.disabledExchanges],
+	enabledExchanges: [...state.enabledExchanges],
+	_enabledExchanges: { ...state._enabledExchanges }
+});
+//#endregion
+export { getStateValues };
+
+//# sourceMappingURL=getStateValues.js.map

package/dist/esm/stores/settings/utils/getStateValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStateValues.js","names":[],"sources":["../../../../../src/stores/settings/utils/getStateValues.ts"],"sourcesContent":["import type { SettingsProps, SettingsState } from '../types.js'\n\nexport const getStateValues = (state: SettingsState): SettingsProps => ({\n  gasPrice: state.gasPrice,\n  language: state.language,\n  languageCache: state.languageCache,\n  lastDefaultLanguage: state.lastDefaultLanguage,\n  routePriority: state.routePriority,\n  enabledAutoRefuel: state.enabledAutoRefuel,\n  slippage: state.slippage,\n  disabledBridges: [...state.disabledBridges],\n  enabledBridges: [...state.enabledBridges],\n  _enabledBridges: { ...state._enabledBridges },\n  disabledExchanges: [...state.disabledExchanges],\n  enabledExchanges: [...state.enabledExchanges],\n  _enabledExchanges: { ...state._enabledExchanges },\n})\n"],"mappings":";AAEA,MAAa,kBAAkB,WAAyC;CACtE,UAAU,MAAM;CAChB,UAAU,MAAM;CAChB,eAAe,MAAM;CACrB,qBAAqB,MAAM;CAC3B,eAAe,MAAM;CACrB,mBAAmB,MAAM;CACzB,UAAU,MAAM;CAChB,iBAAiB,CAAC,GAAG,MAAM,eAAe;CAC1C,gBAAgB,CAAC,GAAG,MAAM,cAAc;CACxC,iBAAiB,EAAE,GAAG,MAAM,gBAAgB;CAC5C,mBAAmB,CAAC,GAAG,MAAM,iBAAiB;CAC9C,kBAAkB,CAAC,GAAG,MAAM,gBAAgB;CAC5C,mBAAmB,EAAE,GAAG,MAAM,kBAAkB;AAClD"}

package/dist/esm/themes/azureLight.d.ts

@@ -0,0 +1,7 @@
+import { WidgetTheme } from "../types/widget.js";
+
+//#region src/themes/azureLight.d.ts
+declare const azureLightTheme: WidgetTheme;
+//#endregion
+export { azureLightTheme };
+//# sourceMappingURL=azureLight.d.ts.map

package/dist/esm/themes/azureLight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"azureLight.d.ts","names":[],"sources":["../../../src/themes/azureLight.ts"],"mappings":";;;cAGa,eAAA,EAAiB,WAAA"}

package/dist/esm/themes/azureLight.js

@@ -0,0 +1,41 @@
+import { tabsClasses } from "@mui/material";
+//#region src/themes/azureLight.ts
+const azureLightTheme = {
+	colorSchemes: { light: { palette: {
+		primary: { main: "#006Eff" },
+		secondary: { main: "#FFC800" },
+		background: {
+			default: "#ffffff",
+			paper: "#f8f8fa"
+		},
+		text: {
+			primary: "#00070F",
+			secondary: "#6A7481"
+		},
+		grey: {
+			200: "#EEEFF2",
+			300: "#D5DAE1",
+			700: "#555B62",
+			800: "#373F48"
+		},
+		playground: { main: "#f3f5f8" }
+	} } },
+	shape: {
+		borderRadius: 12,
+		borderRadiusSecondary: 12,
+		borderRadiusTertiary: 24
+	},
+	typography: { fontFamily: "Inter, sans-serif" },
+	container: {
+		filter: "drop-shadow(0px 8px 32px rgba(0, 0, 0, 0.08))",
+		borderRadius: "16px"
+	},
+	components: {
+		MuiCard: { defaultProps: { variant: "filled" } },
+		MuiNavigationTabs: { styleOverrides: { root: { [`.${tabsClasses.indicator}`]: { backgroundColor: "#f8f8fa" } } } }
+	}
+};
+//#endregion
+export { azureLightTheme };
+
+//# sourceMappingURL=azureLight.js.map

package/dist/esm/themes/azureLight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"azureLight.js","names":[],"sources":["../../../src/themes/azureLight.ts"],"sourcesContent":["import { tabsClasses } from '@mui/material'\nimport type { WidgetTheme } from '../types/widget.js'\n\nexport const azureLightTheme: WidgetTheme = {\n  colorSchemes: {\n    light: {\n      palette: {\n        primary: {\n          main: '#006Eff',\n        },\n        secondary: {\n          main: '#FFC800',\n        },\n        background: {\n          default: '#ffffff',\n          paper: '#f8f8fa',\n        },\n        text: {\n          primary: '#00070F',\n          secondary: '#6A7481',\n        },\n        grey: {\n          200: '#EEEFF2',\n          300: '#D5DAE1',\n          700: '#555B62',\n          800: '#373F48',\n        },\n        playground: {\n          main: '#f3f5f8',\n        },\n      },\n    },\n  },\n  shape: {\n    borderRadius: 12,\n    borderRadiusSecondary: 12,\n    borderRadiusTertiary: 24,\n  },\n  typography: {\n    fontFamily: 'Inter, sans-serif',\n  },\n  container: {\n    filter: 'drop-shadow(0px 8px 32px rgba(0, 0, 0, 0.08))',\n    borderRadius: '16px',\n  },\n  components: {\n    MuiCard: {\n      defaultProps: { variant: 'filled' },\n    },\n    // Used only for 'split' mode and can be safely removed if not used\n    MuiNavigationTabs: {\n      styleOverrides: {\n        root: {\n          [`.${tabsClasses.indicator}`]: {\n            backgroundColor: '#f8f8fa',\n          },\n        },\n      },\n    },\n  },\n}\n"],"mappings":";;AAGA,MAAa,kBAA+B;CAC1C,cAAc,EACZ,OAAO,EACL,SAAS;EACP,SAAS,EACP,MAAM,UACR;EACA,WAAW,EACT,MAAM,UACR;EACA,YAAY;GACV,SAAS;GACT,OAAO;EACT;EACA,MAAM;GACJ,SAAS;GACT,WAAW;EACb;EACA,MAAM;GACJ,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;EACP;EACA,YAAY,EACV,MAAM,UACR;CACF,EACF,EACF;CACA,OAAO;EACL,cAAc;EACd,uBAAuB;EACvB,sBAAsB;CACxB;CACA,YAAY,EACV,YAAY,oBACd;CACA,WAAW;EACT,QAAQ;EACR,cAAc;CAChB;CACA,YAAY;EACV,SAAS,EACP,cAAc,EAAE,SAAS,SAAS,EACpC;EAEA,mBAAmB,EACjB,gBAAgB,EACd,MAAM,GACH,IAAI,YAAY,cAAc,EAC7B,iBAAiB,UACnB,EACF,EACF,EACF;CACF;AACF"}

package/dist/esm/themes/createTheme.d.ts

@@ -0,0 +1,8 @@
+import { WidgetTheme } from "../types/widget.js";
+import { Theme } from "@mui/material";
+
+//#region src/themes/createTheme.d.ts
+declare const createTheme$1: (widgetTheme?: WidgetTheme) => Theme;
+//#endregion
+export { createTheme$1 as createTheme };
+//# sourceMappingURL=createTheme.d.ts.map

package/dist/esm/themes/createTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTheme.d.ts","names":[],"sources":["../../../src/themes/createTheme.ts"],"mappings":";;;;cAuCa,aAAA,GAAe,WAAA,GAAa,WAAA,KAAmB,KAAA"}