@rango-dev/widget-embedded 0.21.1-next.1 → 0.21.1-next.10

package/src/containers/App/App.tsx

@@ -7,6 +7,7 @@ import { AppRouter } from '../../components/AppRouter';
 import { AppRoutes } from '../../components/AppRoutes';
 import { WidgetEvents } from '../../components/WidgetEvents';
 import { globalFont } from '../../globalStyles';
+import { useFetchApiConfig } from '../../hooks/useFetchApiConfig';
 import { useLanguage } from '../../hooks/useLanguage';
 import { useTheme } from '../../hooks/useTheme';
 import { useAppStore } from '../../store/AppStore';
@@ -25,10 +26,11 @@ export function Main() {
     useState<string>('');
   const [disconnectedWallet, setDisconnectedWallet] = useState<WalletType>();
   const widgetContext = useContext(WidgetContext);
-
+  const { fetchApiConfig } = useFetchApiConfig();
   useEffect(() => {
     void useNotificationStore.persist.rehydrate();
     widgetContext.onConnectWallet(setLastConnectedWalletWithNetwork);
+    void fetchApiConfig().catch(console.log);
   }, []);
 
   return (

package/src/hooks/useFetchApiConfig.ts

@@ -0,0 +1,33 @@
+import { useUiStore } from '../store/ui';
+import { getConfig } from '../utils/configs';
+
+export type Watermark = 'NONE' | 'FULL';
+
+type ConfigResponse = {
+  config: {
+    watermark: Watermark;
+  };
+};
+
+interface UseFetchApiConfig {
+  fetchApiConfig: () => Promise<void>;
+}
+
+export function useFetchApiConfig(): UseFetchApiConfig {
+  const { setWatermark } = useUiStore();
+
+  const fetchApiConfig: UseFetchApiConfig['fetchApiConfig'] = async () => {
+    const response = await fetch(
+      `${getConfig('BASE_URL')}/meta/dapp/config?apiKey=${getConfig('API_KEY')}`
+    );
+
+    if (!response.ok) {
+      throw new Error(`Request failed with status: ${response.status} `);
+    }
+
+    const data: ConfigResponse = await response.json();
+
+    setWatermark(data.config.watermark);
+  };
+  return { fetchApiConfig };
+}

package/src/hooks/useIframe/index.ts

@@ -0,0 +1 @@
+export { useIframe } from './useIframe';

package/src/hooks/useIframe/useIframe.helpers.ts

@@ -0,0 +1,3 @@
+export function isAppLoadedIntoIframe() {
+  return window.self !== window.top;
+}

package/src/hooks/useIframe/useIframe.ts

@@ -0,0 +1,55 @@
+import type { Messages } from './useIframe.types';
+
+import { useRef } from 'react';
+
+import { useAppStore } from '../../store/AppStore';
+
+import { isAppLoadedIntoIframe } from './useIframe.helpers';
+
+interface UseIframe {
+  send: (message: Messages) => void;
+  connectHeightObserver: (element: HTMLElement) => void;
+  disconnectHeightObserver: () => void;
+}
+
+function useIframe(): UseIframe {
+  const heightObserver = useRef<ResizeObserver | null>(null);
+  const { iframe } = useAppStore();
+  const isMessagePassingAvailable = isAppLoadedIntoIframe() && iframe.clientUrl;
+
+  const send = (message: Messages) => {
+    if (isMessagePassingAvailable) {
+      window.top?.postMessage(message, iframe.clientUrl!);
+    }
+  };
+
+  const connectHeightObserver = (element: HTMLElement) => {
+    heightObserver.current = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        send({
+          type: 'widget_height',
+          data: {
+            height: entry.contentRect.height,
+          },
+        });
+      }
+    });
+
+    heightObserver.current.observe(element);
+  };
+
+  const disconnectHeightObserver = () => {
+    if (heightObserver.current) {
+      heightObserver.current.disconnect();
+      heightObserver.current = null;
+    }
+  };
+
+  return {
+    send,
+    connectHeightObserver,
+    disconnectHeightObserver,
+  };
+}
+
+export { useIframe };

package/src/hooks/useIframe/useIframe.types.ts

@@ -0,0 +1,13 @@
+type Message<T, D> = {
+  type: T;
+  data: D;
+};
+type WidgetHeightMessage = Message<
+  'widget_height',
+  {
+    height: number;
+  }
+>;
+
+// Add new types of messages to this union.
+export type Messages = WidgetHeightMessage;

package/src/hooks/useSwapInput.ts

@@ -11,7 +11,7 @@ import { isPositiveNumber } from '../utils/numbers';
 import { generateQuoteWarnings } from '../utils/quote';
 import { isFeatureEnabled } from '../utils/settings';
 import { createQuoteRequestBody } from '../utils/swap';
-import { tokensAreEqual } from '../utils/wallets';
+import { areTokensEqual } from '../utils/wallets';
 
 import {
   handleQuoteErrors,
@@ -68,7 +68,7 @@ export function useSwapInput(): UseSwapInput {
   const tokensValueInvalid = !fromToken || !toToken;
   const shouldSkipRequest =
     tokensValueInvalid ||
-    tokensAreEqual(fromToken, toToken) ||
+    areTokensEqual(fromToken, toToken) ||
     !isPositiveNumber(inputAmount);
 
   const resetState = (loading: boolean) => {

package/src/hooks/useSyncStoresWithConfig.ts

@@ -8,7 +8,7 @@ import {
   isBlockchainExcludedInConfig,
   isTokenExcludedInConfig,
 } from '../utils/configs';
-import { tokensAreEqual } from '../utils/wallets';
+import { areTokensEqual } from '../utils/wallets';
 
 export function useSyncStoresWithConfig() {
   const {
@@ -50,7 +50,7 @@ export function useSyncStoresWithConfig() {
         (chain) => chain.name === config?.from?.blockchain
       );
       const token = tokens.find((t) =>
-        tokensAreEqual(t, config?.from?.token || null)
+        areTokensEqual(t, config?.from?.token || null)
       );
 
       if (chain || (!chain && prevConfigFromBlockchain.current)) {
@@ -99,7 +99,7 @@ export function useSyncStoresWithConfig() {
         (chain) => chain.name === config?.to?.blockchain
       );
       const token = tokens.find((t) =>
-        tokensAreEqual(t, config?.to?.token || null)
+        areTokensEqual(t, config?.to?.token || null)
       );
 
       if (chain || (!chain && prevConfigToBlockchain.current)) {

package/src/hooks/useSyncUrlAndStore/useSyncUrlAndStore.ts

@@ -33,6 +33,7 @@ export function useSyncUrlAndStore() {
   const blockchains = useAppStore().blockchains();
   const tokens = useAppStore().tokens();
   const isInRouterContext = useInRouterContext();
+  const { updateIframe } = useAppStore();
 
   const getUrlSearchParams = () => {
     const fromAmount = searchParams.get(SearchParams.FROM_AMOUNT);
@@ -41,6 +42,7 @@ export function useSyncUrlAndStore() {
     const toBlockchain = searchParams.get(SearchParams.TO_BLOCKCHAIN);
     const toToken = searchParams.get(SearchParams.TO_TOKEN);
     const autoConnect = searchParams.get(SearchParams.AUTO_CONNECT);
+    const clientUrl = searchParams.get(SearchParams.CLIENT_URL);
 
     return {
       fromAmount,
@@ -49,6 +51,7 @@ export function useSyncUrlAndStore() {
       toBlockchain,
       toToken,
       autoConnect,
+      clientUrl,
     };
   };
 
@@ -64,7 +67,7 @@ export function useSyncUrlAndStore() {
   };
 
   useEffect(() => {
-    const { autoConnect } = getUrlSearchParams();
+    const { autoConnect, clientUrl } = getUrlSearchParams();
     if (isInRouterContext && fetchMetaStatus === 'success') {
       updateUrlSearchParams({
         [SearchParams.FROM_BLOCKCHAIN]: fromBlockchain?.name,
@@ -73,6 +76,7 @@ export function useSyncUrlAndStore() {
         [SearchParams.TO_TOKEN]: tokenToSearchParam(toToken),
         [SearchParams.FROM_AMOUNT]: inputAmount,
         [SearchParams.AUTO_CONNECT]: autoConnect ?? undefined,
+        [SearchParams.CLIENT_URL]: clientUrl ?? undefined,
       });
     }
   }, [
@@ -132,4 +136,10 @@ export function useSyncUrlAndStore() {
       }
     }
   }, [fetchMetaStatus]);
+
+  // We run this only once, because if the app is embedded into an iframe, the data in url for iframe will not change.
+  useEffect(() => {
+    const { clientUrl } = getUrlSearchParams();
+    updateIframe('clientUrl', clientUrl || undefined);
+  }, []);
 }

package/src/index.ts

@@ -55,6 +55,7 @@ import {
 import { Networks, WalletTypes } from '@rango-dev/wallets-shared';
 import { PendingSwapNetworkStatus } from 'rango-types';
 
+import { WIDGET_UI_ID as UI_ID } from './constants';
 import { WidgetWallets } from './containers/Wallets';
 import { Widget } from './containers/Widget';
 import { useWidget } from './containers/WidgetInfo';
@@ -105,6 +106,7 @@ export {
   StepEventType,
   StepExecutionEventStatus,
   StepExecutionBlockedEventStatus,
+  UI_ID,
 };
 
 // Internal type exports for Rango

package/src/pages/HistoryPage.tsx

@@ -6,15 +6,15 @@ import { Divider, NotFound, styled } from '@rango-dev/ui';
 import React, { useState } from 'react';
 import { useNavigate } from 'react-router-dom';
 
+import { HistoryGroupedList } from '../components/HistoryGroupedList';
+import { NotFoundContainer } from '../components/HistoryGroupedList/HistoryGroupedList.styles';
 import { Layout, PageContainer } from '../components/Layout';
 import { SearchInput } from '../components/SearchInput';
-import { SwapsGroup } from '../components/SwapsGroup';
-import { NotFoundContainer } from '../components/SwapsGroup/SwapsGroup.styles';
 import { groupSwapsByDate } from '../utils/date';
 import { containsText } from '../utils/numbers';
 import { getPendingSwaps } from '../utils/queue';
 
-const SwapsGroupContainer = styled('div', {
+const HistoryGroupedListContainer = styled('div', {
   overflowY: 'visible',
   width: '100%',
   display: 'flex',
@@ -77,7 +77,7 @@ export function HistoryPage() {
           value={searchedFor}
         />
         <Divider size="16" />
-        <SwapsGroupContainer>
+        <HistoryGroupedListContainer>
           {isEmpty && (
             <NotFoundContainer>
               <Divider size={32} />
@@ -90,14 +90,14 @@ export function HistoryPage() {
             </NotFoundContainer>
           )}
           {!isEmpty && (
-            <SwapsGroup
+            <HistoryGroupedList
               list={filteredList}
               onSwapClick={navigate}
               groupBy={groupSwapsByDate}
               isLoading={loading}
             />
           )}
-        </SwapsGroupContainer>
+        </HistoryGroupedListContainer>
       </PageContainer>
     </Layout>
   );

package/src/pages/Home.tsx

@@ -62,7 +62,7 @@ export function Home() {
     setQuoteWarningsConfirmed,
   } = useQuoteStore();
 
-  const fetchMetaStatus = useAppStore().fetchStatus;
+  const { config, fetchStatus: fetchMetaStatus } = useAppStore();
 
   const { connectedWallets, getBalanceFor } = useWalletsStore();
   const { isActiveTab } = useUiStore();
@@ -125,7 +125,6 @@ export function Home() {
   return (
     <Layout
       height="auto"
-      hasLogo
       footer={
         <Button
           type="primary"
@@ -152,7 +151,7 @@ export function Home() {
           navigate(navigationRoutes.wallets);
         },
         hasBackButton: false,
-        title: i18n.t('Swap'),
+        title: config.title || i18n.t('Swap'),
         suffix: (
           <HomeButtons
             onClickRefresh={

package/src/store/notification.ts

@@ -34,13 +34,13 @@ export const useNotificationStore = createSelectors(
             route: {
               from: {
                 blockchain: fromStep.fromBlockchain,
-                tokenAddress: fromStep.fromSymbolAddress,
-                tokenSymbol: fromStep.fromSymbol,
+                address: fromStep.fromSymbolAddress,
+                symbol: fromStep.fromSymbol,
               },
               to: {
                 blockchain: toStep.toBlockchain,
-                tokenSymbol: toStep.toSymbol,
-                tokenAddress: toStep.toSymbolAddress,
+                address: toStep.toSymbolAddress,
+                symbol: toStep.toSymbol,
               },
             },
           };

package/src/store/slices/config.ts

@@ -3,15 +3,31 @@ import type { StateCreatorWithInitialData } from '../app';
 
 export const DEFAULT_CONFIG: WidgetConfig = {
   apiKey: '',
+  title: undefined,
   multiWallets: true,
   enableNewLiquiditySources: true,
   customDestination: true,
 };
 
+interface IframeConfigs {
+  clientUrl?: string;
+}
+
+const DEFAULT_IFRAME_CONFIGS: IframeConfigs = {
+  clientUrl: undefined,
+};
+
 export type ConfigSlice = {
+  // What user can set directly.
   config: WidgetConfig;
-
   updateConfig: (config: WidgetConfig) => void;
+
+  // What we are setting based on enviroments.
+  iframe: { clientUrl?: string };
+  updateIframe: <K extends keyof IframeConfigs>(
+    name: K,
+    value: IframeConfigs[K]
+  ) => void;
 };
 
 export const createConfigSlice: StateCreatorWithInitialData<
@@ -21,6 +37,7 @@ export const createConfigSlice: StateCreatorWithInitialData<
 > = (initialData, set, get) => {
   return {
     config: { ...DEFAULT_CONFIG, ...initialData },
+    iframe: DEFAULT_IFRAME_CONFIGS,
 
     // Actions
     updateConfig: (nextConfig: WidgetConfig) => {
@@ -33,5 +50,16 @@ export const createConfigSlice: StateCreatorWithInitialData<
         },
       });
     },
+
+    updateIframe: (name, value) => {
+      const currentIframeConfig = get().iframe;
+
+      set({
+        iframe: {
+          ...currentIframeConfig,
+          [name]: value,
+        },
+      });
+    },
   };
 };

package/src/store/slices/data.ts

@@ -8,7 +8,7 @@ import { httpService as sdk } from '../../services/httpService';
 import { containsText } from '../../utils/common';
 import { isTokenExcludedInConfig } from '../../utils/configs';
 import { sortLiquiditySourcesByGroupTitle } from '../../utils/settings';
-import { tokensAreEqual } from '../../utils/wallets';
+import { areTokensEqual } from '../../utils/wallets';
 
 type BlockchainOptions = {
   type?: 'source' | 'destination';
@@ -163,7 +163,7 @@ export const createDataSlice: StateCreator<
         ? get().config.from?.pinnedTokens
         : get().config.to?.pinnedTokens;
     const pinned = !!pinnedTokens?.some((pinnedToken) =>
-      tokensAreEqual(pinnedToken, token)
+      areTokensEqual(pinnedToken, token)
     );
     return pinned;
   },

package/src/store/ui.ts

@@ -1,3 +1,4 @@
+import type { Watermark } from '../hooks/useFetchApiConfig';
 import type { TabManagerInterface } from '../libs/tabManager';
 
 import { create } from 'zustand';
@@ -10,11 +11,13 @@ interface UiState {
   isActiveTab: boolean;
   tabManagerInitiated: boolean;
   showActivateTabModal: boolean;
+  watermark: Watermark;
   activateCurrentTab: (
     setCurrentTabAsActive: () => void,
     hasRunningSwaps: boolean
   ) => void;
   setShowActivateTabModal: (flag: boolean) => void;
+  setWatermark: (watermark: Watermark) => void;
 }
 
 export const useUiStore = createSelectors(
@@ -22,6 +25,8 @@ export const useUiStore = createSelectors(
     isActiveTab: false,
     tabManagerInitiated: false,
     showActivateTabModal: false,
+    watermark: 'NONE',
+    fetchingApiConfig: false,
     activateCurrentTab: (setCurrentTabAsActive, hasRunningSwaps) => {
       const { showActivateTabModal } = get();
 
@@ -34,6 +39,9 @@ export const useUiStore = createSelectors(
     setShowActivateTabModal: (flag) => {
       set({ showActivateTabModal: flag });
     },
+    setWatermark: (watermark) => {
+      set({ watermark });
+    },
   }))
 );
 

package/src/types/config.ts

@@ -184,6 +184,7 @@ export type Features = Partial<
 export type WidgetConfig = {
   apiKey: string;
   apiUrl?: string;
+  title?: string;
   walletConnectProjectId?: string;
   affiliate?: WidgetAffiliate;
   amount?: number;

package/src/types/notification.ts

@@ -8,13 +8,13 @@ import {
 type NotificationRoute = {
   from: {
     blockchain: Step['fromBlockchain'];
-    tokenSymbol: Step['fromSymbol'];
-    tokenAddress: Step['fromSymbolAddress'];
+    symbol: Step['fromSymbol'];
+    address: Step['fromSymbolAddress'];
   };
   to: {
     blockchain: Step['toBlockchain'];
-    tokenSymbol: Step['toSymbol'];
-    tokenAddress: Step['toSymbolAddress'];
+    symbol: Step['toSymbol'];
+    address: Step['toSymbolAddress'];
   };
 };
 

package/src/utils/common.ts

@@ -1,4 +1,4 @@
-import { RANGO_SWAP_BOX_ID } from '../constants';
+import { WIDGET_UI_ID } from '../constants';
 
 export function removeDuplicateFrom<T>(array: T[]): T[] {
   return Array.from(new Set(array));
@@ -33,4 +33,4 @@ export function containsText(text: string, searchText: string): boolean {
 }
 
 export const getContainer = () =>
-  document.getElementById(RANGO_SWAP_BOX_ID) as HTMLElement;
+  document.getElementById(WIDGET_UI_ID.SWAP_BOX_ID) as HTMLElement;

package/src/utils/configs.ts

@@ -3,7 +3,7 @@ import type { Asset, BlockchainMeta, Token } from 'rango-sdk';
 
 import { RANGO_PUBLIC_API_KEY } from '../constants';
 
-import { tokensAreEqual } from './wallets';
+import { areTokensEqual } from './wallets';
 
 export interface Configs {
   API_KEY: string;
@@ -57,10 +57,10 @@ export const isTokenExcludedInConfig = (
   let result = false;
   if (tokensConfig && token) {
     if (Array.isArray(tokensConfig)) {
-      result = !tokensConfig.some((asset) => tokensAreEqual(asset, token));
+      result = !tokensConfig.some((asset) => areTokensEqual(asset, token));
     } else if (!Array.isArray(tokensConfig) && tokensConfig[token.blockchain]) {
       result = tokensConfig[token.blockchain].tokens.some((asset) =>
-        tokensAreEqual(asset, token)
+        areTokensEqual(asset, token)
       );
       const isExcluded = tokensConfig[token.blockchain].isExcluded;
       return (!isExcluded && !result) || (isExcluded && result);

package/src/utils/date.ts

@@ -1,4 +1,4 @@
-import type { GroupBy } from '../components/SwapsGroup/SwapsGroup.types';
+import type { GroupBy } from '../components/HistoryGroupedList/HistoryGroupedList.types';
 import type { PendingSwap } from 'rango-types';
 
 import { i18n } from '@lingui/core';
@@ -70,5 +70,12 @@ export const groupSwapsByDate: GroupBy = (swaps) => {
     }
   });
 
-  return Array.from(output.values());
+  const groupedSwaps = Array.from(output.values()).filter(
+    (item) => item.swaps.length > 0
+  );
+  const items = groupedSwaps.flatMap((group) => group.swaps);
+  const groupCounts = groupedSwaps.map((group) => group.swaps.length);
+  const groups = groupedSwaps.map((group) => group.title);
+
+  return { swaps: items, groupCounts, groups };
 };

package/src/utils/meta.ts

@@ -1,6 +1,6 @@
 import type { Asset, BlockchainMeta, SwapperMeta, Token } from 'rango-sdk';
 
-import { tokensAreEqual } from './wallets';
+import { areTokensEqual } from './wallets';
 
 export function getBlockchainDisplayNameFor(
   blockchainName: string,
@@ -25,7 +25,7 @@ export function getSwapperDisplayName(
 }
 
 export function findToken(t: Asset, tokens: Token[]) {
-  return tokens.find((token) => tokensAreEqual(token, t)) ?? null;
+  return tokens.find((token) => areTokensEqual(token, t)) ?? null;
 }
 
 export function findBlockchain(name: string, blockchains: BlockchainMeta[]) {

package/src/utils/wallets.ts

@@ -443,7 +443,7 @@ export function sortTokens(
   return tokens;
 }
 
-export function tokensAreEqual(
+export function areTokensEqual(
   tokenA: Pick<Token, 'blockchain' | 'symbol' | 'address'> | null,
   tokenB: Pick<Token, 'blockchain' | 'symbol' | 'address'> | null
 ) {

package/dist/components/SwapsGroup/SwapsGroup.d.ts

@@ -1,4 +0,0 @@
-import type { PropTypes } from './SwapsGroup.types';
-import React from 'react';
-export declare function SwapsGroup(props: PropTypes): React.JSX.Element;
-//# sourceMappingURL=SwapsGroup.d.ts.map

package/dist/components/SwapsGroup/SwapsGroup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SwapsGroup.d.ts","sourceRoot":"","sources":["../../../src/components/SwapsGroup/SwapsGroup.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAIpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAW1B,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,qBA6H1C"}

package/dist/components/SwapsGroup/SwapsGroup.styles.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SwapsGroup.styles.d.ts","sourceRoot":"","sources":["../../../src/components/SwapsGroup/SwapsGroup.styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAAQ,CAAC;AAEjC,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAWhB,CAAC;AAEH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAIf,CAAC;AAEH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAInB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAK5B,CAAC"}

package/dist/components/SwapsGroup/SwapsGroup.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SwapsGroup.types.d.ts","sourceRoot":"","sources":["../../../src/components/SwapsGroup/SwapsGroup.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,MAAM,OAAO,GAAG,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB,EAAE,CAAC;AAEJ,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,WAAW,EAAE,CAAC;IACpB,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;CACpB"}

package/dist/components/SwapsGroup/index.d.ts

@@ -1,2 +0,0 @@
-export { SwapsGroup } from './SwapsGroup';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/SwapsGroup/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/SwapsGroup/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}