@qite/tide-booking-component 1.4.124 → 1.4.125

package/src/booking-wizard/features/flight-options/flight-utils.ts

@@ -1,423 +0,0 @@
-import { BookingPackageFlight, BookingPackageFlightMetaDataLine } from '@qite/tide-client/build/types';
-import { differenceInMinutes, isEqual, parseISO } from 'date-fns';
-import { FlightDirectionFilter, FlightFilterOption, FlightFilterOptions, GroupedFlightDetails, GroupedFlights } from '../../types';
-
-/*interface FlightGroup {
-  code: string;
-  startDate: Date,
-  endDate: Date;
-  options: BookingPackageFlight[];
-}*/
-
-export const buildGroupedFlights = (outwardFlights: BookingPackageFlight[] | undefined, returnFlights: BookingPackageFlight[] | undefined) => {
-  if (!outwardFlights || !returnFlights) return [] as GroupedFlights[];
-
-  // let outwardGroups = groupFlights(outwardFlights);
-  // let returnGroups = groupFlights(returnFlights);
-
-  const pairs: {
-    outward: BookingPackageFlight;
-    return: BookingPackageFlight;
-  }[] = [];
-  outwardFlights.forEach((outwardFlight) => {
-    if (outwardFlight.externalGuid) {
-      const returnFlight = returnFlights.find((x) => x.externalGuid === outwardFlight.externalGuid);
-      if (!returnFlight) return;
-
-      pairs.push({ outward: outwardFlight, return: returnFlight });
-    } else {
-      const outwardCode = outwardFlight.code.substring(0, 7);
-      const returnCode = outwardCode.split(' ').reduce((a, b) => `${b} ${a}`);
-
-      returnFlights
-        .filter((x) => x.code.startsWith(returnCode))
-        .forEach((returnFlight) => {
-          pairs.push({ outward: outwardFlight, return: returnFlight });
-        });
-    }
-  });
-
-  const results: GroupedFlights[] = [];
-  pairs.forEach((x) => {
-    const outwardFlightDetails = getFlightDetails(x.outward);
-    const returnFlightDetails = getFlightDetails(x.return);
-
-    if (!outwardFlightDetails || !returnFlightDetails) return;
-
-    results.push({
-      isSelected: x.outward.isSelected && x.return.isSelected,
-      price: x.outward.price + x.return.price,
-      outward: outwardFlightDetails,
-      return: returnFlightDetails,
-      selectedOutward: x.outward,
-      selectedReturn: x.return
-    } as GroupedFlights);
-  });
-
-  return results;
-};
-
-export const buildFilterOptions = (
-  outwardFlights: BookingPackageFlight[] | undefined,
-  returnFlights: BookingPackageFlight[] | undefined,
-  translations: any
-) => {
-  if (!outwardFlights || !returnFlights) return undefined;
-
-  const airports: FlightFilterOption[] = [];
-  const airlines: FlightFilterOption[] = [];
-  const numberOfStops: FlightFilterOption[] = [];
-  const outwardDeparturePeriods: FlightFilterOption[] = [];
-  const returnDeparturePeriods: FlightFilterOption[] = [];
-
-  let lowestDepartureTravelDuration = 9999;
-  let highestDepartureTravelDuration = 0;
-  let lowestDepartureChangeDuration = 9999;
-  let highestDepartureChangeDuration = 0;
-
-  outwardFlights.forEach((flight) => {
-    const airlineCode = flight.code.split('/')[1];
-
-    if (flight.flightMetaData.flightLines?.length) {
-      const firstLine = flight.flightMetaData.flightLines[0];
-
-      if (!airports.some((x) => x.value === firstLine.departureAirport)) {
-        airports.push({
-          value: firstLine?.departureAirport,
-          label: firstLine.departureAirportDescription,
-          count: 0,
-          isSelected: false
-        });
-      }
-    }
-
-    if (!airlines.some((x) => x.value === airlineCode)) {
-      airlines.push({
-        value: airlineCode,
-        label: flight.airlineDescription,
-        count: 0,
-        isSelected: false
-      });
-    }
-
-    const stopCount = flight.flightMetaData.flightLines.length - 1;
-    if (!numberOfStops.some((x) => x.value === stopCount + '')) {
-      numberOfStops.push({
-        value: stopCount + '',
-        label:
-          stopCount === 0
-            ? translations.FLIGHTS_FORM.DIRECT_FLIGHT
-            : stopCount == 1
-            ? `${stopCount} ${translations.FLIGHTS_FORM.STOP}`
-            : `${stopCount} ${translations.FLIGHTS_FORM.STOPS}`,
-        count: 0,
-        isSelected: false
-      });
-    }
-
-    const departureTime = flight.flightMetaData.flightLines[0].departureTime;
-    const timeBracket = determineTimeBracket(departureTime);
-    if (!outwardDeparturePeriods.some((x) => x.value === timeBracket)) {
-      outwardDeparturePeriods.push({
-        value: timeBracket,
-        label: getBracketTranslation(timeBracket, translations),
-        count: 0,
-        isSelected: false
-      });
-    }
-
-    const travelDurationInMinutes = minutesFromTicks(flight.flightMetaData.durationInTicks);
-    if (travelDurationInMinutes > highestDepartureTravelDuration) highestDepartureTravelDuration = travelDurationInMinutes;
-    if (travelDurationInMinutes < lowestDepartureTravelDuration) lowestDepartureTravelDuration = travelDurationInMinutes;
-
-    const changeDurationInMinutes = getTotalChangeDuration(flight);
-    if (changeDurationInMinutes > highestDepartureChangeDuration) highestDepartureChangeDuration = changeDurationInMinutes;
-    if (changeDurationInMinutes < lowestDepartureChangeDuration) lowestDepartureChangeDuration = changeDurationInMinutes;
-  });
-
-  let lowestReturnTravelDuration = 9999;
-  let highestReturnTravelDuration = 0;
-  let lowestReturnChangeDuration = 9999;
-  let highestReturnChangeDuration = 0;
-
-  returnFlights.forEach((flight) => {
-    const durationInMinutes = minutesFromTicks(flight.flightMetaData.durationInTicks);
-    if (durationInMinutes > highestReturnTravelDuration) highestReturnTravelDuration = durationInMinutes;
-    if (durationInMinutes < lowestReturnTravelDuration) lowestReturnTravelDuration = durationInMinutes;
-
-    const changeDurationInMinutes = getTotalChangeDuration(flight);
-    if (changeDurationInMinutes > highestReturnChangeDuration) highestReturnChangeDuration = changeDurationInMinutes;
-    if (changeDurationInMinutes < lowestReturnChangeDuration) lowestReturnChangeDuration = changeDurationInMinutes;
-
-    const departureTime = flight.flightMetaData.flightLines[0].departureTime;
-    const timeBracket = determineTimeBracket(departureTime);
-    if (!returnDeparturePeriods.some((x) => x.value === timeBracket)) {
-      returnDeparturePeriods.push({
-        value: timeBracket,
-        label: getBracketTranslation(timeBracket, translations),
-        count: 0,
-        isSelected: false
-      });
-    }
-  });
-
-  return {
-    airports: airports,
-    airlines: airlines,
-    numberOfStops: numberOfStops,
-    outward: {
-      departurePeriod: outwardDeparturePeriods,
-      travelDuration: {
-        min: lowestDepartureTravelDuration,
-        max: highestDepartureTravelDuration,
-        selectedMin: lowestDepartureTravelDuration,
-        selectedMax: highestDepartureTravelDuration
-      },
-      changeDuration: {
-        min: lowestDepartureChangeDuration,
-        max: highestDepartureChangeDuration,
-        selectedMin: lowestDepartureChangeDuration,
-        selectedMax: highestDepartureChangeDuration
-      }
-    },
-    return: {
-      departurePeriod: returnDeparturePeriods,
-      travelDuration: {
-        min: lowestReturnTravelDuration,
-        max: highestReturnTravelDuration,
-        selectedMin: lowestReturnTravelDuration,
-        selectedMax: highestReturnTravelDuration
-      },
-      changeDuration: {
-        min: lowestReturnChangeDuration,
-        max: highestReturnChangeDuration,
-        selectedMin: lowestReturnChangeDuration,
-        selectedMax: highestReturnChangeDuration
-      }
-    }
-  } as FlightFilterOptions;
-};
-
-export const filterGroupedFlights = (groups: GroupedFlights[], filterOptions: FlightFilterOptions | undefined) => {
-  if (!groups.length || !filterOptions) return [];
-
-  let filteredGroups = groups;
-  if (filterOptions.airlines.some((x) => x.isSelected)) {
-    const selectedAirlineCodes = filterOptions.airlines.filter((x) => x.isSelected);
-    filteredGroups = filteredGroups.filter((x) => selectedAirlineCodes.some((y) => y.value === x.outward.airlineCode));
-  }
-
-  if (filterOptions.airports.some((x) => x.isSelected)) {
-    const selectedAirlineCodes = filterOptions.airports.filter((x) => x.isSelected);
-    filteredGroups = filteredGroups.filter((x) => selectedAirlineCodes.some((y) => y.value === x.outward.departureAirportCode));
-  }
-
-  if (filterOptions.numberOfStops.some((x) => x.isSelected)) {
-    const selectedNumberOfStops = filterOptions.numberOfStops.filter((x) => x.isSelected);
-    filteredGroups = filteredGroups.filter((x) => selectedNumberOfStops.some((y) => parseInt(y.value) === x.outward.flightLines.length - 1));
-  }
-
-  filteredGroups = filterGroupedFlightByDirection(filteredGroups, true, filterOptions.outward);
-  filteredGroups = filterGroupedFlightByDirection(filteredGroups, false, filterOptions.return);
-
-  return filteredGroups;
-};
-
-const filterGroupedFlightByDirection = (groups: GroupedFlights[], isOutward: boolean, directionFilter: FlightDirectionFilter) => {
-  let filteredGroups = groups;
-
-  if (directionFilter.departurePeriod.some((x) => x.isSelected)) {
-    const selectedDeparturePeriods = directionFilter.departurePeriod.filter((x) => x.isSelected);
-    filteredGroups = filteredGroups.filter((x) =>
-      selectedDeparturePeriods.some((y) => y.value === determineTimeBracket((isOutward ? x.outward : x.return).departureTime))
-    );
-  }
-
-  filteredGroups = filteredGroups.filter(
-    (x) =>
-      directionFilter.travelDuration.selectedMin <= (isOutward ? x.outward : x.return).travelDurationMinutes &&
-      (isOutward ? x.outward : x.return).travelDurationMinutes <= directionFilter.travelDuration.selectedMax
-  );
-  return filteredGroups.filter(
-    (x) =>
-      directionFilter.changeDuration.selectedMin <= (isOutward ? x.outward : x.return).changeDurationMinutes &&
-      (isOutward ? x.outward : x.return).changeDurationMinutes <= directionFilter.changeDuration.selectedMax
-  );
-};
-
-export const formatMinutes = (minutes: number) => {
-  var hh = Math.floor(minutes / 60);
-  var mm = Math.floor(minutes % 60);
-  return pad(hh, 2) + ':' + pad(mm, 2);
-};
-
-const getFlightDetails = (flight: BookingPackageFlight) => {
-  if (flight.flightMetaData == null) return;
-  const firstLine = flight.flightMetaData.flightLines[0];
-  const lastLine = flight.flightMetaData.flightLines[flight.flightMetaData.flightLines.length - 1];
-
-  const airlineCode = flight.code.split('/')[1];
-  const waitDurations = getWaitDurations(flight.flightMetaData.flightLines);
-
-  return {
-    airline: flight.airlineDescription,
-    airlineCode: airlineCode,
-    departureDate: firstLine.departureDate,
-    departureTime: firstLine.departureTime,
-    departureAirportCode: firstLine.departureAirport,
-    departureAirport: firstLine.departureAirportDescription,
-    arrivalDate: lastLine.arrivalDate,
-    arrivalTime: lastLine.arrivalTime,
-    arrivalAirport: lastLine.arrivalAirportDescription,
-    travelDuration: formatDuration(flight.flightMetaData.durationInTicks),
-    travelDurationMinutes: minutesFromTicks(flight.flightMetaData.durationInTicks),
-    changeDurationMinutes: getTotalChangeDuration(flight),
-    numberOfStops: flight.flightMetaData.flightLines.length - 1,
-    isNextDay: isNextDay(firstLine.departureDate, lastLine.arrivalDate),
-    travelClass: firstLine.travelClass,
-    flightLines: flight.flightMetaData.flightLines.map((x, i) => ({
-      airline: x.operatingAirlineDescription,
-      departureDate: x.departureDate,
-      departureTime: x.departureTime,
-      departureAirport: x.departureAirportDescription,
-      arrivalDate: x.arrivalDate,
-      arrivalTime: x.arrivalTime,
-      arrivalAirport: x.arrivalAirportDescription,
-      number: `${x.airlineCode} ${x.number}`,
-      travelDuration: formatDuration(x.durationInTicks),
-      waitDuration: waitDurations.length - 1 <= i ? waitDurations[i] : undefined
-    }))
-  } as GroupedFlightDetails;
-};
-
-const isNextDay = (startDateString: string, endDateString: string) => {
-  const startDate = parseISO(startDateString);
-  const endDate = parseISO(endDateString);
-
-  return !isEqual(startDate, endDate);
-};
-
-const getWaitDurations = (lines: BookingPackageFlightMetaDataLine[]) => {
-  if (lines.length <= 1) return [];
-  let arrivalDate = lines[0].arrivalDate;
-  let arrivalTime = lines[0].arrivalTime;
-
-  const waitDurations: string[] = [];
-  for (var i = 1; i < lines.length; i++) {
-    const line = lines[i];
-
-    const waitDuration = getWaitDuration(arrivalDate, arrivalTime, line.departureDate, line.departureTime);
-    waitDurations.push(waitDuration);
-
-    arrivalDate = line.arrivalDate;
-    arrivalTime = line.arrivalTime;
-  }
-
-  return waitDurations;
-};
-
-const getWaitDuration = (arrivalDateString: string, arrivalTime: string, departureDateString: string, departureTime: string) => {
-  const minutes = getWaitDurationInMinutes(arrivalDateString, arrivalTime, departureDateString, departureTime);
-
-  var hh = Math.floor(minutes / 60);
-  var mm = Math.floor(minutes % 60);
-  return pad(hh, 2) + ':' + pad(mm, 2);
-};
-
-const getWaitDurationInMinutes = (arrivalDateString: string, arrivalTime: string, departureDateString: string, departureTime: string) => {
-  const arrivalDate = parseISO(arrivalDateString);
-  const arrivalTimeParts = arrivalTime.split(':');
-
-  arrivalDate.setHours(parseInt(arrivalTimeParts[0]));
-  arrivalDate.setMinutes(parseInt(arrivalTimeParts[1]));
-
-  const departureDate = parseISO(departureDateString);
-  const departureTimeParts = departureTime.split(':');
-
-  departureDate.setHours(parseInt(departureTimeParts[0]));
-  departureDate.setMinutes(parseInt(departureTimeParts[1]));
-
-  return differenceInMinutes(departureDate, arrivalDate);
-};
-
-/*const groupFlights = (flights: BookingPackageFlight[]) => {
-  let flightsPool = [...flights];
-  let groups = [] as FlightGroup[];
-  for (var i = 0; i < flightsPool.length; i++) {
-    const flight = flightsPool[i];
-
-    const relatedFlights = flightsPool.filter(x => x != flight
-      && x.code === flight.code
-      && isDateEqual(x.startDateTime, flight.startDateTime)
-      && isDateEqual(x.endDateTime, flight.endDateTime)
-    );
-
-    flightsPool = flightsPool.filter(x => x != flight
-      && relatedFlights.some(y => y != x));
-
-    groups.push({
-      code: flight.code,
-      startDate: parseISO(flight.startDateTime),
-      endDate: parseISO(flight.endDateTime),
-      options: [flight, ...relatedFlights]
-    });
-  }
-}
-
-const isDateEqual = (first: string, second: string) => {
-  const firstDate = parseISO(first);
-  const secondDate = parseISO(second);
-
-  return isEqual(firstDate, secondDate);
-}*/
-
-const minutesFromTicks = (ticks: number) => {
-  const totalSeconds = ticks / 10_000_000;
-  return Math.floor(totalSeconds / 60);
-};
-
-const formatDuration = (ticks: number) => {
-  if (!ticks) return '';
-
-  const totalSeconds = ticks / 10_000_000;
-  var hh = Math.floor(totalSeconds / 3600);
-  var mm = Math.floor((totalSeconds % 3600) / 60);
-  return pad(hh, 2) + ':' + pad(mm, 2);
-};
-
-const pad = (input: number, width: number) => {
-  const n = input + '';
-  return n.length >= width ? n : new Array(width - n.length + 1).join('0') + n;
-};
-
-const determineTimeBracket = (input: string) => {
-  const time = parseInt(input.replace(':', ''));
-  if (time <= 500) return '0000-0500';
-  if (time > 500 && time <= 1200) return '0500-1200';
-  if (time > 1200 && time <= 1800) return '1201-1800';
-  return '1800-2400';
-};
-
-const getBracketTranslation = (input: string, translations: any) => {
-  if (input === '0000-0500') return translations.FLIGHTS_FORM.NIGHT_DEPARTURE;
-  if (input === '0500-1200') return translations.FLIGHTS_FORM.MORNING_DEPARTURE;
-  if (input === '1200-1800') return translations.FLIGHTS_FORM.AFTERNOON_DEPARTURE;
-  return translations.FLIGHTS_FORM.EVENING_DEPARTURE;
-};
-
-const getTotalChangeDuration = (flight: BookingPackageFlight) => {
-  const lines = flight.flightMetaData.flightLines;
-
-  if (lines.length <= 1) return 0;
-  let arrivalDate = lines[0].arrivalDate;
-  let arrivalTime = lines[0].arrivalTime;
-
-  let waitDuration = 0;
-  for (var i = 1; i < lines.length; i++) {
-    const line = lines[i];
-
-    waitDuration += getWaitDurationInMinutes(arrivalDate, arrivalTime, line.departureDate, line.departureTime);
-  }
-
-  return waitDuration;
-};

package/src/booking-wizard/features/flight-options/index.tsx

@@ -1,170 +0,0 @@
-import React, { useContext, useEffect, useState } from 'react';
-
-import { BookingPackageFlight } from '@qite/tide-client/build/types';
-import { isEmpty } from 'lodash';
-import { useSelector } from 'react-redux';
-import { buildClassName } from '../../../shared/utils/class-util';
-import SettingsContext from '../../settings-context';
-import { useAppDispatch } from '../../store';
-import { FlightFilterOptions, GroupedFlights } from '../../types';
-import { setCurrentStep, setFlights, setPackage } from '../booking/booking-slice';
-import { OPTIONS_FORM_STEP, ROOM_OPTIONS_FORM_STEP, TRAVELERS_FORM_STEP } from '../booking/constants';
-import {
-  selectBookingQueryString,
-  selectIsFetchingProductOptions,
-  selectPackageDetails,
-  selectPackageFlights,
-  selectTranslations,
-  selectTravelersFirstStep
-} from '../booking/selectors';
-import { fetchPriceDetails } from '../price-details/price-details-slice';
-import FlightFilter from './flight-filter';
-import FlightOption from './flight-option';
-import FlightOptionModal from './flight-option-modal';
-import { buildFilterOptions, buildGroupedFlights, filterGroupedFlights } from './flight-utils';
-import { Link, useNavigate } from 'react-router-dom';
-
-interface FlightOptionsFormProps {}
-
-const FlightOptionsForm: React.FC<FlightOptionsFormProps> = () => {
-  const settings = useContext(SettingsContext);
-  const navigate = settings.skipRouter ? () => {} : useNavigate();
-
-  const translations = useSelector(selectTranslations);
-  const dispatch = useAppDispatch();
-  const packageDetails = useSelector(selectPackageDetails);
-  const bookingQueryString = useSelector(selectBookingQueryString);
-  const isLoading = useSelector(selectIsFetchingProductOptions);
-  const flights = useSelector(selectPackageFlights);
-  const travelersFirstStep = useSelector(selectTravelersFirstStep);
-
-  const [filterOptions, setFilterOptions] = useState<FlightFilterOptions | undefined>();
-  const [flightGroups, setFlightGroups] = useState<GroupedFlights[]>([]);
-
-  const handleSubmit: React.FormEventHandler<HTMLFormElement> = (e) => {
-    if (settings.skipRouter) {
-      if (settings.roomOptions.isHidden) {
-        dispatch(setCurrentStep(OPTIONS_FORM_STEP));
-      } else {
-        dispatch(setCurrentStep(ROOM_OPTIONS_FORM_STEP));
-      }
-    } else {
-      if (settings.roomOptions.isHidden) {
-        navigate(`${!settings.skipBasePathInRouting ? settings.basePath : ''}${settings.options.pathSuffix}?${bookingQueryString}`);
-      } else {
-        navigate(`${!settings.skipBasePathInRouting ? settings.basePath : ''}${settings.roomOptions.pathSuffix}?${bookingQueryString}`);
-      }
-    }
-
-    e.preventDefault();
-  };
-
-  const currentFlightPrice = (flights.outward?.find((x) => x.isSelected)?.price || 0) + (flights.return?.find((x) => x.isSelected)?.price || 0);
-
-  useEffect(() => {
-    if (packageDetails && settings.roomOptions.isHidden) {
-      const params = new URLSearchParams(location.search);
-
-      const outwardFlight = params.get('outwardflight') ?? undefined;
-      const returnFlight = params.get('returnflight') ?? undefined;
-      if (outwardFlight && returnFlight) {
-        const desiredOutwardFlight = packageDetails.outwardFlights.find((x) => x.entryLineGuid == outwardFlight);
-        const desiredReturnFlight = packageDetails.returnFlights.find((x) => x.entryLineGuid == returnFlight);
-        if (desiredOutwardFlight && desiredReturnFlight) {
-          dispatch(
-            setPackage({
-              ...packageDetails,
-              outwardFlights: packageDetails.outwardFlights.map((flight) => {
-                return {
-                  ...flight,
-                  isSelected: flight.entryLineGuid == desiredOutwardFlight.entryLineGuid ? true : false
-                } as BookingPackageFlight;
-              }),
-              returnFlights: packageDetails.returnFlights.map((flight) => {
-                return {
-                  ...flight,
-                  isSelected: flight.entryLineGuid == desiredReturnFlight.entryLineGuid ? true : false
-                } as BookingPackageFlight;
-              })
-            })
-          );
-        }
-      }
-    }
-    dispatch(fetchPriceDetails());
-
-    const filters = buildFilterOptions(flights.outward, flights.return, translations);
-    setFilterOptions(filters);
-  }, []);
-
-  useEffect(() => {
-    const groups = buildGroupedFlights(flights.outward, flights.return);
-    setFlightGroups(groups);
-  }, [flights]);
-
-  const filteredGroups = filterGroupedFlights(flightGroups, filterOptions);
-  const resultCount = filteredGroups.length;
-
-  const goPrevious = () => {
-    dispatch(setCurrentStep(TRAVELERS_FORM_STEP));
-  };
-
-  return (
-    <>
-      <FlightOptionModal />
-      <form className="form" name="booking--flights" id="booking--flights" noValidate onSubmit={handleSubmit}>
-        <div className="form__booking--flight">
-          {isLoading && settings.loaderComponent}
-          {!isLoading && (
-            <div className="form__group">
-              <div className="booking-card">
-                <div className="booking-card__body">
-                  {filterOptions && <FlightFilter filterOptions={filterOptions} resultCount={resultCount} applyFilter={setFilterOptions} />}
-
-                  <div className="booking-card__group">
-                    <div className="flight outward__flights">
-                      {isEmpty(filteredGroups) && <p>{translations.FLIGHTS_FORM.NO_FLIGHTS_FOUND}</p>}
-
-                      {!isEmpty(filteredGroups) &&
-                        filteredGroups.map((flight, index) => (
-                          <FlightOption
-                            key={index}
-                            item={flight}
-                            isSelected={flight.isSelected}
-                            currentPrice={currentFlightPrice}
-                            onChange={(item) => {
-                              dispatch(setFlights(item));
-                              dispatch(fetchPriceDetails());
-                            }}
-                          />
-                        ))}
-                    </div>
-                  </div>
-                </div>
-              </div>
-            </div>
-          )}
-        </div>
-        <div className="booking__navigator">
-          {travelersFirstStep && settings.skipRouter ? (
-            <button type="button" title={translations.STEPS.PREVIOUS} onClick={() => goPrevious()} className="cta cta--secondary">
-              {translations.STEPS.PREVIOUS}
-            </button>
-          ) : travelersFirstStep ? (
-            <Link
-              to={`${!settings.skipBasePathInRouting ? settings.basePath : ''}${settings.travellers.pathSuffix}?${bookingQueryString}`}
-              title={translations.STEPS.PREVIOUS}
-              className="cta cta--secondary">
-              {translations.STEPS.PREVIOUS}
-            </Link>
-          ) : null}
-          <button type="submit" title={translations.STEPS.NEXT} disabled={isLoading} className={buildClassName(['cta', isLoading && 'cta--disabled'])}>
-            {translations.STEPS.NEXT}
-          </button>
-        </div>
-      </form>
-    </>
-  );
-};
-
-export default FlightOptionsForm;

package/src/booking-wizard/features/price-details/price-details-api.ts

@@ -1,20 +0,0 @@
-import { priceDetails } from '@qite/tide-client';
-import { BookingPackageBookRequest, BookingPackageRequest, BookingPriceDetails } from '@qite/tide-client/build/types';
-import { ApiSettingsState } from '../../../shared/types';
-import { buildTideClientConfig } from '../../../shared/utils/tide-api-utils';
-
-const fetchPriceDetails = async (
-  apiSettings: ApiSettingsState,
-  request: BookingPackageRequest<BookingPackageBookRequest>,
-  signal: AbortSignal,
-  languageCode?: string
-): Promise<BookingPriceDetails> => {
-  const tideClientConfig = buildTideClientConfig(apiSettings);
-  return await priceDetails(tideClientConfig, request, signal, languageCode);
-};
-
-const priceDetailsApi = {
-  fetchPriceDetails
-};
-
-export default priceDetailsApi;

package/src/booking-wizard/features/price-details/price-details-slice.ts

@@ -1,79 +0,0 @@
-import { createAsyncThunk, createSlice, PayloadAction } from '@reduxjs/toolkit';
-import { RootState } from '../../store';
-import { BookingPriceDetail, BookingPriceDetails, BookingProductNotification } from '@qite/tide-client/build/types';
-import { setPackage } from '../booking/booking-slice';
-import { selectBookingPackageBookRequest, selectLanguageCode, selectPackageDetails } from '../booking/selectors';
-import priceDetailsApi from './price-details-api';
-import { updatePackageDetails } from './util';
-
-export interface PriceDetailsState {
-  priceDetails: BookingPriceDetail[];
-  notifications: BookingProductNotification[];
-  deposit?: number;
-  commission?: number;
-  isBusy: boolean;
-}
-
-export const fetchPriceDetails = createAsyncThunk('priceDetails/fetchPriceDetails', async (_, { dispatch, getState, signal }) => {
-  dispatch(setFetchingPriceDetails(true));
-  dispatch(resetPriceDetails());
-
-  const state = getState() as RootState;
-  const languageCode = selectLanguageCode(state);
-
-  const request = selectBookingPackageBookRequest(state);
-
-  if (!request) {
-    throw Error('Product not available.');
-  }
-
-  const priceDetails: BookingPriceDetails = await priceDetailsApi.fetchPriceDetails(state.apiSettings, request, signal, languageCode);
-
-  dispatch(setFetchingPriceDetails(false));
-
-  const packageDetails = selectPackageDetails(state);
-  if (packageDetails) {
-    const updatedPackageDetails = updatePackageDetails(packageDetails, priceDetails.changedLines);
-    dispatch(setPackage(updatedPackageDetails));
-  }
-
-  return priceDetails;
-});
-
-const priceDetailsSlice = createSlice({
-  name: 'priceDetails',
-  initialState: <PriceDetailsState>{
-    priceDetails: [],
-    notifications: [],
-    isBusy: false
-  },
-  reducers: {
-    setFetchingPriceDetails(state, action: PayloadAction<boolean>) {
-      state.isBusy = action.payload;
-    },
-    setNotifications(state, action: PayloadAction<BookingProductNotification[]>) {
-      state.notifications = action.payload;
-    },
-    resetPriceDetails(state, _: PayloadAction<void>) {
-      state.priceDetails = [];
-    }
-  },
-  extraReducers: (builder) => {
-    builder.addCase(fetchPriceDetails.fulfilled, (state, action) => {
-      if (action.payload) {
-        state.deposit = action.payload.deposit;
-        state.commission = action.payload.commission;
-        state.priceDetails = action.payload.details;
-        state.notifications = action.payload.notifications;
-      }
-    });
-  }
-});
-
-const { setFetchingPriceDetails } = priceDetailsSlice.actions;
-
-export const { resetPriceDetails, setNotifications } = priceDetailsSlice.actions;
-
-export const selectNotifications = (state: RootState) => state.priceDetails.notifications;
-
-export default priceDetailsSlice.reducer;