@lifi/widget 3.0.0-alpha.0 → 3.0.0-alpha.10

package/App.tsx

@@ -0,0 +1,29 @@
+'use client';
+import { forwardRef, useMemo } from 'react';
+import { AppDefault } from './AppDefault';
+import type { WidgetDrawer } from './AppDrawer';
+import { AppDrawer } from './AppDrawer';
+import { AppProvider } from './AppProvider';
+import type { WidgetConfig, WidgetProps } from './types';
+
+export const App = forwardRef<WidgetDrawer, WidgetProps>(
+  ({ elementRef, open, integrator, ...other }, ref) => {
+    const config: WidgetConfig = useMemo(
+      () => ({ integrator, ...other, ...other.config }),
+      [integrator, other],
+    );
+    return config?.variant !== 'drawer' ? (
+      <AppProvider config={config}>
+        <AppDefault />
+      </AppProvider>
+    ) : (
+      <AppDrawer
+        ref={ref}
+        elementRef={elementRef}
+        integrator={integrator}
+        config={config}
+        open={open}
+      />
+    );
+  },
+);

package/AppDefault.tsx

@@ -0,0 +1,35 @@
+'use client';
+import { AppRoutes } from './AppRoutes';
+import {
+  AppContainer,
+  AppExpandedContainer,
+  FlexContainer,
+} from './components/AppContainer';
+import { Header } from './components/Header';
+import { Initializer } from './components/Initializer';
+import { PoweredBy } from './components/PoweredBy';
+import { RoutesExpanded } from './components/Routes';
+import { useExpandableVariant } from './hooks';
+import { useWidgetConfig } from './providers';
+import { ElementId, createElementId } from './utils';
+
+export const AppDefault = () => {
+  const { elementId } = useWidgetConfig();
+  const expandable = useExpandableVariant();
+
+  return (
+    <AppExpandedContainer
+      id={createElementId(ElementId.AppExpandedContainer, elementId)}
+    >
+      <AppContainer>
+        <Header />
+        <FlexContainer disableGutters>
+          <AppRoutes />
+        </FlexContainer>
+        <PoweredBy />
+        <Initializer />
+      </AppContainer>
+      {expandable ? <RoutesExpanded /> : null}
+    </AppExpandedContainer>
+  );
+};

package/AppDrawer.style.tsx

@@ -0,0 +1,109 @@
+import { Button, IconButton, Typography } from '@mui/material';
+import { styled } from '@mui/material/styles';
+
+const getButtonTransformWidth = (
+  drawerWidth?: number | string,
+  drawerMaxWidth?: number | string,
+) => {
+  if (typeof drawerWidth === 'number') {
+    return `${drawerWidth}px`;
+  }
+  if (typeof drawerWidth === 'string' && !drawerWidth.includes('%')) {
+    return drawerWidth;
+  }
+  if (typeof drawerMaxWidth === 'number') {
+    return `${drawerMaxWidth}px`;
+  }
+  if (typeof drawerMaxWidth === 'string' && !drawerMaxWidth.includes('%')) {
+    return drawerMaxWidth;
+  }
+  return '392px';
+};
+
+export const DrawerButton = styled(Button, {
+  shouldForwardProp: (prop) =>
+    !['open', 'drawerProps'].includes(prop as string),
+})<{
+  open?: boolean;
+  drawerProps?: {
+    width?: number | string;
+    maxWidth?: number | string;
+  };
+}>(({ theme, open, drawerProps }) => ({
+  background:
+    theme.palette.mode === 'light'
+      ? theme.palette.common.black
+      : theme.palette.common.white,
+  color:
+    theme.palette.mode === 'light'
+      ? theme.palette.common.white
+      : theme.palette.common.black,
+  alignItems: 'center',
+  borderRadius: `${theme.shape.borderRadiusSecondary}px 0 0 ${theme.shape.borderRadiusSecondary}px`,
+  display: 'flex',
+  flexDirection: 'column',
+  justifyContent: 'center',
+  minHeight: 144,
+  minWidth: 40,
+  padding: theme.spacing(1, 0, 1, 0),
+  position: 'absolute',
+  right: 0,
+  top: 'calc(50% - 74px)',
+  transform: `translate3d(calc(${
+    open
+      ? getButtonTransformWidth(drawerProps?.width, drawerProps?.maxWidth)
+      : '0px'
+  } * -1), 0, 0)`,
+  transition: theme.transitions.create(['transform'], {
+    duration: open
+      ? theme.transitions.duration.enteringScreen
+      : theme.transitions.duration.leavingScreen,
+    easing: open
+      ? theme.transitions.easing.easeOut
+      : theme.transitions.easing.sharp,
+  }),
+  zIndex: 1500,
+  '&:hover': {
+    background:
+      theme.palette.mode === 'light'
+        ? theme.palette.common.black
+        : theme.palette.common.white,
+  },
+  svg: {
+    color:
+      theme.palette.mode === 'light'
+        ? theme.palette.common.white
+        : theme.palette.common.black,
+  },
+}));
+
+export const DrawerButtonTypography = styled(Typography)(({ theme }) => ({
+  borderRadius: `0 ${theme.shape.borderRadiusSecondary}px ${theme.shape.borderRadiusSecondary}px 0`,
+  background:
+    theme.palette.mode === 'light'
+      ? theme.palette.common.black
+      : theme.palette.common.white,
+  color:
+    theme.palette.mode === 'light'
+      ? theme.palette.common.white
+      : theme.palette.common.black,
+  cursor: 'pointer',
+  display: 'flex',
+  flexDirection: 'row',
+  padding: theme.spacing(1),
+  position: 'relative',
+  textTransform: 'none',
+  transform: 'rotateZ(180deg)',
+  writingMode: 'vertical-rl',
+}));
+
+export const CloseButtonLayout = styled(IconButton)(() => ({
+  position: 'absolute',
+  top: '12px',
+  right: '26px',
+  zIndex: 1,
+  height: '40px',
+  width: '40px',
+  alignItems: 'center',
+  justifyContent: 'center',
+}));

package/AppDrawer.tsx

@@ -0,0 +1,141 @@
+import CloseIcon from '@mui/icons-material/CloseRounded';
+import KeyboardArrowLeftIcon from '@mui/icons-material/KeyboardArrowLeft';
+import KeyboardArrowRightIcon from '@mui/icons-material/KeyboardArrowRight';
+import { Drawer } from '@mui/material';
+import {
+  forwardRef,
+  useCallback,
+  useImperativeHandle,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+import { useTranslation } from 'react-i18next';
+import { AppDefault } from './AppDefault';
+import {
+  CloseButtonLayout,
+  DrawerButton,
+  DrawerButtonTypography,
+} from './AppDrawer.style';
+import { AppProvider } from './AppProvider';
+import type { WidgetConfig, WidgetProps, WidgetSubvariant } from './types';
+import { HiddenUI } from './types';
+
+export interface WidgetDrawer {
+  isOpen(): void;
+  toggleDrawer(): void;
+  openDrawer(): void;
+  closeDrawer(): void;
+}
+
+export const AppDrawer = forwardRef<WidgetDrawer, WidgetProps>(
+  ({ elementRef, open, integrator, config }, ref) => {
+    const openRef = useRef(open);
+    const [drawerOpen, setDrawerOpen] = useState(Boolean(open));
+
+    const toggleDrawer = useCallback(() => {
+      setDrawerOpen((open) => !open);
+    }, []);
+
+    const openDrawer = useCallback(() => {
+      setDrawerOpen(true);
+    }, []);
+
+    const closeDrawer = useCallback(() => {
+      setDrawerOpen(false);
+    }, []);
+
+    useImperativeHandle(
+      ref,
+      () => ({
+        isOpen: () => openRef.current,
+        toggleDrawer,
+        openDrawer,
+        closeDrawer,
+      }),
+      [closeDrawer, openDrawer, toggleDrawer],
+    );
+
+    const widgetConfig: WidgetConfig = useMemo(
+      () => ({
+        ...config,
+        integrator,
+        containerStyle: {
+          ...config?.containerStyle,
+          height: '100%',
+        },
+      }),
+      [config, integrator],
+    );
+
+    return (
+      <AppProvider config={widgetConfig}>
+        {!widgetConfig.hiddenUI?.includes(HiddenUI.DrawerButton) ? (
+          <DrawerButton
+            variant="contained"
+            onClick={toggleDrawer}
+            open={drawerOpen}
+            drawerProps={config?.containerStyle}
+          >
+            {drawerOpen ? (
+              <KeyboardArrowRightIcon />
+            ) : (
+              <KeyboardArrowLeftIcon />
+            )}
+            <DrawerButtonText
+              open={drawerOpen}
+              subvariant={config?.subvariant}
+            />
+          </DrawerButton>
+        ) : null}
+        <Drawer
+          ref={elementRef}
+          anchor="right"
+          open={drawerOpen}
+          onClose={closeDrawer}
+          slotProps={{
+            backdrop: {
+              sx: {
+                backgroundColor: 'rgb(0 0 0 / 48%)',
+                backdropFilter: 'blur(3px)',
+              },
+            },
+          }}
+          PaperProps={{
+            sx: {
+              width: config?.containerStyle?.width ?? '100%',
+              minWidth: config?.containerStyle?.minWidth ?? 360,
+              maxWidth: config?.containerStyle?.maxWidth ?? 392,
+            },
+          }}
+          keepMounted
+        >
+          <CloseButtonLayout onClick={closeDrawer} edge="end">
+            <CloseIcon />
+          </CloseButtonLayout>
+          <AppDefault />
+        </Drawer>
+      </AppProvider>
+    );
+  },
+);
+
+export const DrawerButtonText = ({
+  open,
+  subvariant,
+}: {
+  open: boolean;
+  subvariant?: WidgetSubvariant;
+}) => {
+  const { t } = useTranslation();
+
+  return (
+    <DrawerButtonTypography>
+      {open
+        ? t('button.hide')
+        : subvariant === 'nft'
+          ? t('button.lifiCheckout')
+          : t('button.lifiExchange')}
+    </DrawerButtonTypography>
+  );
+};

package/AppProvider.tsx

@@ -0,0 +1,51 @@
+import { QueryClientProvider } from '@tanstack/react-query';
+import type { PropsWithChildren } from 'react';
+import { Fragment } from 'react';
+import { MemoryRouter, useInRouterContext } from 'react-router-dom';
+import { queryClient } from './config/queryClient';
+import {
+  FormProvider,
+  I18nProvider,
+  ThemeProvider,
+  URLSearchParamsBuilder,
+  WalletProvider,
+  WidgetProvider,
+  useWidgetConfig,
+} from './providers';
+import { StoreProvider } from './stores';
+import type { WidgetConfigProps } from './types';
+
+export const AppProvider: React.FC<PropsWithChildren<WidgetConfigProps>> = ({
+  children,
+  config,
+}) => {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <WidgetProvider config={config}>
+        <ThemeProvider>
+          <I18nProvider>
+            <WalletProvider>
+              <FormProvider>
+                <StoreProvider config={config}>
+                  <AppRouter>{children}</AppRouter>
+                </StoreProvider>
+              </FormProvider>
+            </WalletProvider>
+          </I18nProvider>
+        </ThemeProvider>
+      </WidgetProvider>
+    </QueryClientProvider>
+  );
+};
+
+export const AppRouter: React.FC<PropsWithChildren<{}>> = ({ children }) => {
+  const { buildUrl } = useWidgetConfig();
+  const inRouterContext = useInRouterContext();
+  const Router = inRouterContext ? Fragment : MemoryRouter;
+  return (
+    <Router>
+      {children}
+      {buildUrl ? <URLSearchParamsBuilder /> : null}
+    </Router>
+  );
+};

package/AppRoutes.tsx

@@ -0,0 +1,99 @@
+import type { RouteObject } from 'react-router-dom';
+import { useLocation, useRoutes } from 'react-router-dom';
+import { NotFound } from './components/NotFound';
+import { ActiveTransactionsPage } from './pages/ActiveTransactionsPage';
+import { LanguagesPage } from './pages/LanguagesPage';
+import { MainPage } from './pages/MainPage';
+import { RoutesPage } from './pages/RoutesPage';
+import { SelectChainPage } from './pages/SelectChainPage';
+import { SelectEnabledToolsPage } from './pages/SelectEnabledToolsPage';
+import { SelectTokenPage } from './pages/SelectTokenPage';
+import { SelectWalletPage } from './pages/SelectWalletPage';
+import { SettingsPage } from './pages/SettingsPage';
+import { TransactionDetailsPage } from './pages/TransactionDetailsPage';
+import { TransactionHistoryPage } from './pages/TransactionHistoryPage';
+import { TransactionPage } from './pages/TransactionPage';
+import { navigationRoutes } from './utils';
+
+// SelectWalletPage should be accessible from every page and this handler helps avoid creating multiple paths.
+// Avoid using it for anything else, we need to come up with a better solution once we have one more page accessible from everywhere.
+const NotFoundRouteHandler = () => {
+  const { pathname } = useLocation();
+  return pathname.includes(navigationRoutes.selectWallet) ? (
+    <SelectWalletPage />
+  ) : (
+    <NotFound />
+  );
+};
+
+const routes: RouteObject[] = [
+  {
+    path: '/',
+    element: <MainPage />,
+  },
+  {
+    path: navigationRoutes.settings,
+    element: <SettingsPage />,
+  },
+  {
+    path: `${navigationRoutes.settings}/${navigationRoutes.bridges}`,
+    element: <SelectEnabledToolsPage type="Bridges" />,
+  },
+  {
+    path: `${navigationRoutes.settings}/${navigationRoutes.exchanges}`,
+    element: <SelectEnabledToolsPage type="Exchanges" />,
+  },
+  {
+    path: `${navigationRoutes.settings}/${navigationRoutes.languages}`,
+    element: <LanguagesPage />,
+  },
+  {
+    path: navigationRoutes.fromToken,
+    element: <SelectTokenPage formType="from" />,
+  },
+  {
+    path: navigationRoutes.toToken,
+    element: <SelectTokenPage formType="to" />,
+  },
+  {
+    path: navigationRoutes.toTokenNative,
+    element: <SelectChainPage formType="to" selectNativeToken />,
+  },
+  {
+    path: `${navigationRoutes.fromToken}?/${navigationRoutes.fromChain}`,
+    element: <SelectChainPage formType="from" />,
+  },
+  {
+    path: `${navigationRoutes.toToken}?/${navigationRoutes.toChain}`,
+    element: <SelectChainPage formType="to" />,
+  },
+  {
+    path: navigationRoutes.routes,
+    element: <RoutesPage />,
+  },
+  {
+    path: navigationRoutes.activeTransactions,
+    element: <ActiveTransactionsPage />,
+  },
+  {
+    path: navigationRoutes.transactionHistory,
+    element: <TransactionHistoryPage />,
+  },
+  {
+    path: `${navigationRoutes.transactionHistory}?/${navigationRoutes.routes}?/${navigationRoutes.transactionExecution}?/${navigationRoutes.transactionDetails}`,
+    element: <TransactionDetailsPage />,
+  },
+  {
+    path: `${navigationRoutes.routes}?/${navigationRoutes.activeTransactions}?/${navigationRoutes.transactionExecution}`,
+    element: <TransactionPage />,
+  },
+  {
+    path: '*',
+    element: <NotFoundRouteHandler />,
+  },
+];
+
+export const AppRoutes = () => {
+  const element = useRoutes(routes);
+  return element;
+};