@eventlook/sdk 1.4.46-beta.2 → 1.4.46-beta.3

package/src/form/tickets/TicketWithMerchandiseSelection.tsx

@@ -1,174 +0,0 @@
-import React, { useEffect, useRef } from 'react';
-import { useFormContext, useWatch } from 'react-hook-form';
-import { Box, Skeleton, Stack, Typography } from '@mui/material';
-import { ITicketForm, ITicketFormTicket } from '@utils/types/ticket.type';
-import useEventActiveReleases from '@hooks/data/useEventActiveReleases';
-import { groupBy } from '@utils/global';
-import { IReleaseShort } from '@utils/types/release.type';
-import { IEvent } from '@utils/types/event.type';
-import ReleaseWithMerchandise from '@form/tickets/ReleaseWithMerchandise';
-import { EventType } from '@utils/data/event';
-import useGlobal from '@hooks/useGlobal.ts';
-
-interface Props {
-  event: IEvent;
-}
-
-const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
-  const { t } = useGlobal();
-  const { setValue, watch } = useFormContext<ITicketForm>();
-  const tickets: ITicketFormTicket[] = useWatch({ name: `tickets.${event.id}`, defaultValue: [] });
-  const eventTimeslotId = watch('eventTimeslotId');
-  const isProcessingRef = useRef(false);
-  const { data: activeReleases, mutate } = useEventActiveReleases(
-    event.id,
-    false,
-    event.type === EventType.RECURRING ? eventTimeslotId : undefined
-  );
-
-  useEffect(() => {
-    if (!isProcessingRef.current) selectedTickets();
-  }, [tickets, activeReleases]);
-
-  const countReleaseCategories = (): number => {
-    const grouped = groupBy(activeReleases || [], 'releaseCategoryName');
-    return Object.keys(grouped).length;
-  };
-
-  const selectedReleaseIsSoldOut = (releases: IReleaseShort[] | undefined) => {
-    const lockedSelectedReleases: boolean[] | undefined = releases?.map((item, index) => {
-      const nextRelease = releases?.find(
-        (item2) =>
-          item2.releaseCategoryName === item.releaseCategoryName && item2.order === item.order + 1
-      );
-      const selected = tickets.find((ticket) => ticket.releaseId === item.id);
-      return !!nextRelease && item.locked && !!selected && index + 1 == tickets.length;
-    });
-    return lockedSelectedReleases && lockedSelectedReleases.includes(true);
-  };
-
-  const countUnlockedReleases = () => activeReleases?.filter((item) => !item.locked).length || 0;
-
-  const isReleaseSelected = (id: number) => !!tickets.find((ticket) => ticket.releaseId === id);
-
-  const selectedTickets = async () => {
-    const releases = await mutate();
-    const allFilled = tickets.filter((item) => !item.releaseId || !item.quantity);
-
-    const soldOutReleaseCategories = activeReleases?.filter((release) =>
-      tickets.find(
-        (ticket) =>
-          release.id === ticket.releaseId &&
-          ticket.quantity === release.availableTickets &&
-          release.availableTickets !== 10
-      )
-    );
-
-    // Unlock next releases when current release is sold out
-    if (soldOutReleaseCategories?.length && activeReleases) {
-      let hasChanges = false;
-      const updatedReleases = activeReleases.map((release) => {
-        // For each sold-out release, find and unlock the next one
-        const soldOutRelease = soldOutReleaseCategories.find(
-          (soldOut) =>
-            soldOut.releaseCategoryName === release.releaseCategoryName &&
-            soldOut.order === release.order - 1 &&
-            release.locked
-        );
-        if (soldOutRelease) {
-          hasChanges = true;
-          return { ...release, locked: false };
-        }
-        return release;
-      });
-
-      if (hasChanges) {
-        await mutate(updatedReleases, false);
-      }
-    }
-
-    const hasSelectableRelease = activeReleases?.some(
-      (release) => !isReleaseSelected(release.id) && !release.locked
-    );
-
-    const shouldAddRow =
-      (soldOutReleaseCategories &&
-        selectedReleaseIsSoldOut(releases) &&
-        tickets.length < soldOutReleaseCategories.length + countUnlockedReleases() &&
-        !allFilled.length) ||
-      (activeReleases &&
-        soldOutReleaseCategories?.length &&
-        activeReleases?.length > tickets.length &&
-        tickets.length < soldOutReleaseCategories.length + countUnlockedReleases() &&
-        !allFilled.length) ||
-      (tickets.length < countReleaseCategories() && !allFilled.length);
-
-    const shouldRemoveEmptyRows =
-      allFilled.length > 0 &&
-      tickets.length > 1 &&
-      !hasSelectableRelease &&
-      (!soldOutReleaseCategories?.length || !selectedReleaseIsSoldOut(releases));
-
-    if (shouldAddRow) {
-      isProcessingRef.current = true;
-      setValue(`tickets.${event.id}`, [
-        ...tickets,
-        {
-          releaseId: '',
-          quantity: '',
-          itemName: '',
-          price: 0,
-          products: [],
-          extraFields: [],
-        },
-      ]);
-      setTimeout(() => (isProcessingRef.current = false), 0);
-    } else if (shouldRemoveEmptyRows) {
-      // Only remove completely empty rows (no releaseId), keep rows where user started selecting
-      const nonEmptyTickets = tickets.filter((item) => item.releaseId);
-      if (nonEmptyTickets.length < tickets.length) {
-        isProcessingRef.current = true;
-        setValue(`tickets.${event.id}`, nonEmptyTickets);
-        setTimeout(() => (isProcessingRef.current = false), 0);
-      }
-    }
-  };
-
-  return (
-    <Stack spacing={1} direction="column">
-      {!activeReleases && event.type !== EventType.RECURRING ? (
-        <Skeleton
-          variant="rounded"
-          sx={{
-            width: '100%',
-            height: (theme) => theme.spacing(7.5),
-          }}
-        />
-      ) : (
-        activeReleases?.map((release, index) => (
-          <ReleaseWithMerchandise
-            key={release.id}
-            eventId={event.id}
-            release={release}
-            activeReleases={activeReleases}
-            currency={event.currency}
-            index={index}
-          />
-        ))
-      )}
-      {!activeReleases && event.type === EventType.RECURRING && (
-        <Typography variant="h5">{t('event.tickets.stepper.1.select_timeslot')}</Typography>
-      )}
-      {!!activeReleases && !activeReleases.length && (
-        <Typography variant="h5">{t('event.tickets.stepper.1.no_tickets')}</Typography>
-      )}
-      <Box>
-        <Typography variant="caption" component="div" fontStyle="italic" mb={2}>
-          *{t('event.tickets.stepper.1.max_ticket_quantity')}
-        </Typography>
-      </Box>
-    </Stack>
-  );
-};
-
-export default TicketWithMerchandiseSelection;

package/src/form/timeslot/TimeslotCalendar.tsx

@@ -1,112 +0,0 @@
-import React, { Dispatch, SetStateAction } from 'react';
-import dayjs, { Dayjs } from 'dayjs';
-import { DateCalendar, PickersDay, PickersDayProps } from '@mui/x-date-pickers';
-import { Box } from '@mui/material';
-
-const Day: React.FC<
-  PickersDayProps<Dayjs> & {
-    selectedDay?: string | null;
-    selectedDays?: string[];
-    setSelectedDate?: (date: string | null) => void;
-    disableUnselectedDays?: boolean;
-  }
-> = ({
-  selectedDay,
-  selectedDays = [],
-  setSelectedDate = () => {},
-  day,
-  outsideCurrentMonth,
-  disableUnselectedDays,
-  disabled,
-  ...other
-}) => {
-  const isCurrentDay = !!selectedDay && selectedDay.indexOf(day.format('YYYY-MM-DD')) >= 0;
-  const isSelected =
-    !outsideCurrentMonth && (selectedDays.indexOf(day.format('YYYY-MM-DD')) >= 0 || isCurrentDay);
-
-  return (
-    <Box>
-      <PickersDay
-        {...other}
-        outsideCurrentMonth={outsideCurrentMonth}
-        day={day}
-        selected={isSelected}
-        disabled={disabled || (disableUnselectedDays && !isSelected)}
-        onClick={() => setSelectedDate(day.format('YYYY-MM-DD'))}
-        sx={{
-          ...other.sx,
-          ...(!isCurrentDay && {
-            '&.Mui-selected': {
-              backgroundColor: 'common.white',
-              color: 'primary.main',
-              border: '1px solid',
-              '&:hover, &:focus': {
-                backgroundColor: 'primary.lighter',
-              },
-            },
-          }),
-        }}
-      />
-    </Box>
-  );
-};
-
-interface Props {
-  selectedDay: string | null;
-  selectedDays: string[];
-  setSelectedDate: (date: string | null) => void;
-  activeMonth?: Dayjs;
-  setActiveMonth?: Dispatch<SetStateAction<Dayjs | null>>;
-  disableUnselectedDays?: boolean;
-}
-
-const TimeslotCalendar: React.FC<Props> = ({
-  selectedDay,
-  selectedDays,
-  setSelectedDate,
-  activeMonth,
-  setActiveMonth,
-  disableUnselectedDays,
-}) => {
-  const handleMonthChange = (date: Dayjs) => {
-    if (setActiveMonth) {
-      setActiveMonth(dayjs(date));
-    }
-  };
-
-  const handleYearChange = (date: Dayjs) => {
-    if (setActiveMonth) {
-      setActiveMonth(dayjs(date));
-    }
-  };
-
-  return (
-    <DateCalendar
-      minDate={dayjs()}
-      slots={{
-        day: Day,
-      }}
-      slotProps={{
-        day: {
-          selectedDay,
-          selectedDays,
-          setSelectedDate,
-          disableUnselectedDays,
-        } as any,
-      }}
-      value={activeMonth}
-      onMonthChange={handleMonthChange}
-      onYearChange={handleYearChange}
-      views={['year', 'month', 'day']}
-      dayOfWeekFormatter={(day, date) => dayjs(date).format('ddd').slice(0, 2).toUpperCase()}
-      sx={{
-        m: 0,
-        borderRadius: 2,
-        border: (theme) => `1px solid ${theme.palette.grey.A200}`,
-        boxShadow: (theme) => theme.shadows[10],
-      }}
-    />
-  );
-};
-
-export default TimeslotCalendar;

package/src/hooks/data/useActiveEventProducts.ts

@@ -1,21 +0,0 @@
-import useSWR from 'swr';
-import { getActiveEventProducts } from '@modules/event';
-import { IEventProduct } from '@utils/types/event-product.type';
-
-export default function useActiveEventProducts(id?: number, inlcudeChildren?: boolean) {
-  const { data, error, mutate, isValidating } = useSWR<IEventProduct[]>(
-    ['active-event-products', id, inlcudeChildren],
-    id ? () => getActiveEventProducts(id, inlcudeChildren) : null,
-    {
-      revalidateOnMount: true,
-    }
-  );
-
-  return {
-    data: data ? data : [],
-    error,
-    mutate,
-    isValidating,
-    isLoading: !error && !data,
-  };
-}

package/src/hooks/data/useAllowedPaymentMethods.ts

@@ -1,22 +0,0 @@
-import useSWR from 'swr';
-import { getAllowedPaymentMethods } from '@modules/order';
-import { Currencies } from '@utils/data/currency';
-import { IPaymentMethod } from '@utils/types/payment-method.type';
-
-export default function useAllowedPaymentMethods(currency: Currencies, eventId?: number) {
-  const { data, error, mutate, isValidating } = useSWR<IPaymentMethod[]>(
-    ['allowed-payment-methods', currency, eventId],
-    () => getAllowedPaymentMethods(currency, eventId),
-    {
-      revalidateOnMount: true,
-    }
-  );
-
-  return {
-    data,
-    error,
-    mutate,
-    isValidating,
-    isLoading: !error && !data,
-  };
-}

package/src/hooks/data/useEvent.ts

@@ -1,21 +0,0 @@
-import useSWR from 'swr';
-import { getEventBySlug } from '@modules/event';
-import { IEvent } from '@utils/types/event.type';
-
-export default function useEvent(slug?: string) {
-  const { data, error, mutate, isValidating } = useSWR<IEvent>(
-    ['event', slug],
-    slug ? (_: any) => getEventBySlug(slug) : null,
-    {
-      revalidateOnMount: true,
-    }
-  );
-
-  return {
-    data: data,
-    error,
-    mutate,
-    isValidating,
-    isLoading: !error && !data,
-  };
-}

package/src/hooks/data/useEventActiveReleases.ts

@@ -1,29 +0,0 @@
-import useSWR from 'swr';
-import { getEventActiveReleases } from '@modules/event';
-import { IReleaseShort } from '@utils/types/release.type';
-
-export default function useEventActiveReleases(
-  id?: number,
-  includeChildren?: boolean,
-  timeslotId?: number | null
-) {
-  const { data, error, mutate, isValidating } = useSWR<IReleaseShort[]>(
-    ['event-active-releases', id, includeChildren, timeslotId],
-    id
-      ? timeslotId === undefined || !!timeslotId
-        ? () => getEventActiveReleases(id, includeChildren, timeslotId)
-        : null
-      : null,
-    {
-      revalidateOnMount: true,
-    }
-  );
-
-  return {
-    data: data,
-    error,
-    mutate,
-    isValidating,
-    isLoading: !error && !data,
-  };
-}

package/src/hooks/data/useEventShippingMethods.ts

@@ -1,21 +0,0 @@
-import useSWR from 'swr';
-import { getEventShippingMethods } from '@modules/event';
-import { IShippingMethod, IShippingMethodFilter } from '@utils/types/shipping-method.type';
-
-export default function useEventShippingMethods(id?: number, filters?: IShippingMethodFilter) {
-  const { data, error, mutate, isValidating } = useSWR<IShippingMethod[]>(
-    ['event-shipping-methods', id, filters],
-    id ? () => getEventShippingMethods(id, filters) : null,
-    {
-      revalidateOnMount: true,
-    }
-  );
-
-  return {
-    data: data ? data : [],
-    error,
-    mutate,
-    isValidating,
-    isLoading: !error && !data,
-  };
-}

package/src/hooks/data/useEventTimeslots.ts

@@ -1,23 +0,0 @@
-import useSWR from 'swr';
-import { IPaginate } from '@utils/types/global.type';
-import { getEventTimeslots } from '@modules/event-timeslot';
-import { IEventTimeslotDate, IEventTimeslotFilters } from '@utils/types/event-timeslot.type';
-
-export default function useEventTimeslots(eventId: number, filters?: IEventTimeslotFilters) {
-  const { data, error, mutate, isValidating } = useSWR<IPaginate<IEventTimeslotDate[]>>(
-    ['event-timeslots', eventId, filters],
-    () => getEventTimeslots(eventId, filters),
-    {
-      revalidateOnMount: true,
-    }
-  );
-
-  return {
-    data: data ? data.data : [],
-    meta: data?.meta,
-    error,
-    mutate,
-    isValidating,
-    isLoading: !error && !data,
-  };
-}

package/src/hooks/useCountdown.ts

@@ -1,45 +0,0 @@
-import { useState, useEffect } from 'react';
-
-// ----------------------------------------------------------------------
-
-export default function useCountdown(date: Date) {
-  const [countdown, setCountdown] = useState({
-    days: '00',
-    hours: '00',
-    minutes: '00',
-    seconds: '00',
-  });
-
-  useEffect(() => {
-    const interval = setInterval(() => setNewTime(), 1000);
-    return () => clearInterval(interval);
-  }, [date]);
-
-  const setNewTime = () => {
-    const startTime = date;
-    const endTime = new Date();
-    const distanceToNow = startTime.valueOf() - endTime.valueOf();
-
-    const getDays = Math.floor(distanceToNow / (1000 * 60 * 60 * 24));
-
-    const getHours = `0${Math.floor(
-      (distanceToNow % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60)
-    )}`.slice(-2);
-
-    const getMinutes = `0${Math.floor((distanceToNow % (1000 * 60 * 60)) / (1000 * 60))}`.slice(-2);
-
-    const getSeconds = `0${Math.floor((distanceToNow % (1000 * 60)) / 1000)}`.slice(-2);
-
-    setCountdown({
-      days: getDays.toString() || '000',
-      hours: getHours || '00',
-      minutes: getMinutes || '00',
-      seconds: getSeconds || '00',
-    });
-  };
-
-  return countdown;
-}
-
-// Usage
-// const countdown = useCountdown(new Date('07/07/2022 21:30'));

package/src/hooks/useDebounce.ts

@@ -1,12 +0,0 @@
-import { useEffect, useState } from 'react';
-
-export default function useDebounce<T>(value: T, delay: number): T {
-  const [debouncedValue, setDebouncedValue] = useState(value);
-
-  useEffect(() => {
-    const handler = setTimeout(() => setDebouncedValue(value), delay);
-    return () => clearTimeout(handler);
-  }, [value, delay]);
-
-  return debouncedValue;
-}

package/src/hooks/useErrors.ts

@@ -1,23 +0,0 @@
-import useGlobal from '@hooks/useGlobal.ts';
-
-const useErrors = (defaultMessage?: string) => {
-  const { t, showSnackbar } = useGlobal();
-
-  const transformErrors = (message: string | string[] | undefined) => {
-    if (Array.isArray(message)) {
-      for (const error of message) {
-        showSnackbar(error, { variant: 'error' });
-      }
-    } else if (message) {
-      showSnackbar(message, { variant: 'error' });
-    } else {
-      showSnackbar(defaultMessage ?? t('error'), { variant: 'error' });
-    }
-  };
-
-  return {
-    transformErrors,
-  };
-};
-
-export default useErrors;

package/src/hooks/useEventListener.ts

@@ -1,71 +0,0 @@
-import { RefObject, useEffect, useRef, useLayoutEffect } from 'react';
-
-// ----------------------------------------------------------------------
-
-const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;
-
-// Window Event based useEventListener interface
-function useEventListener<K extends keyof WindowEventMap>(
-  eventName: K,
-  handler: (event: WindowEventMap[K]) => void,
-  element?: undefined,
-  options?: boolean | AddEventListenerOptions
-): void;
-
-// Element Event based useEventListener interface
-function useEventListener<
-  K extends keyof HTMLElementEventMap,
-  T extends HTMLElement = HTMLDivElement,
->(
-  eventName: K,
-  handler: (event: HTMLElementEventMap[K]) => void,
-  element: RefObject<T>,
-  options?: boolean | AddEventListenerOptions
-): void;
-
-// Document Event based useEventListener interface
-function useEventListener<K extends keyof DocumentEventMap>(
-  eventName: K,
-  handler: (event: DocumentEventMap[K]) => void,
-  element: RefObject<Document>,
-  options?: boolean | AddEventListenerOptions
-): void;
-
-function useEventListener<
-  KW extends keyof WindowEventMap,
-  KH extends keyof HTMLElementEventMap,
-  T extends HTMLElement | void = void,
->(
-  eventName: KW | KH,
-  handler: (event: WindowEventMap[KW] | HTMLElementEventMap[KH] | Event) => void,
-  element?: RefObject<T>,
-  options?: boolean | AddEventListenerOptions
-) {
-  // Create a ref that stores handler
-  const savedHandler = useRef(handler);
-
-  useIsomorphicLayoutEffect(() => {
-    savedHandler.current = handler;
-  }, [handler]);
-
-  useEffect(() => {
-    // Define the listening target
-    const targetElement: T | Window = element?.current || window;
-    if (!(targetElement && targetElement.addEventListener)) {
-      return;
-    }
-
-    // Create event listener that calls handler function stored in ref
-    const eventListener: typeof handler = (event) => savedHandler.current(event);
-
-    targetElement.addEventListener(eventName, eventListener, options);
-
-    // Remove event listener on cleanup
-
-    return () => {
-      targetElement.removeEventListener(eventName, eventListener);
-    };
-  }, [eventName, element, options]);
-}
-
-export default useEventListener;

package/src/hooks/useFirstRender.ts

@@ -1,11 +0,0 @@
-import { useRef, useEffect } from 'react';
-
-export function useFirstRender(): boolean {
-  const firstRender = useRef(true);
-
-  useEffect(() => {
-    firstRender.current = false;
-  }, []);
-
-  return firstRender.current;
-}

package/src/hooks/useGlobal.ts

@@ -1,6 +0,0 @@
-import { useContext } from 'react';
-import { GlobalContext } from '@context/GlobalContext';
-
-const useGlobal = () => useContext(GlobalContext);
-
-export default useGlobal;

package/src/hooks/useResponsive.ts

@@ -1,54 +0,0 @@
-import { Breakpoint } from '@mui/material';
-import { useTheme } from '@mui/material/styles';
-import useMediaQuery from '@mui/material/useMediaQuery';
-
-type Query = 'up' | 'down' | 'between' | 'only';
-type Key = Breakpoint | number;
-type Start = Breakpoint | number;
-type End = Breakpoint | number;
-
-export default function useResponsive(query: Query, key?: Key, start?: Start, end?: End) {
-  const theme = useTheme();
-
-  const mediaUp = useMediaQuery(theme.breakpoints.up(key as Key));
-
-  const mediaDown = useMediaQuery(theme.breakpoints.down(key as Key));
-
-  const mediaBetween = useMediaQuery(theme.breakpoints.between(start as Start, end as End));
-
-  const mediaOnly = useMediaQuery(theme.breakpoints.only(key as Breakpoint));
-
-  if (query === 'up') {
-    return mediaUp;
-  }
-
-  if (query === 'down') {
-    return mediaDown;
-  }
-
-  if (query === 'between') {
-    return mediaBetween;
-  }
-
-  if (query === 'only') {
-    return mediaOnly;
-  }
-}
-
-// ----------------------------------------------------------------------
-
-type BreakpointOrNull = Breakpoint | null;
-
-export function useWidth() {
-  const theme = useTheme();
-
-  const keys = [...theme.breakpoints.keys].reverse();
-
-  return (
-    keys.reduce((output: BreakpointOrNull, key: Breakpoint) => {
-      const matches = useMediaQuery(theme.breakpoints.up(key));
-
-      return !output && matches ? key : output;
-    }, null) || 'xs'
-  );
-}